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.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using CustomDiscoverStateLib;
using ExitGames.Client.Photon;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Utils.Cil;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Photon.Pun;
using Photon.Realtime;
using RepoXR.Assets;
using RepoXR.Data;
using RepoXR.Input;
using RepoXR.Managers;
using RepoXR.Networking;
using RepoXR.Networking.Frames;
using RepoXR.Patches;
using RepoXR.Player;
using RepoXR.Player.Camera;
using RepoXR.Rendering;
using RepoXR.ThirdParty.MRTK;
using RepoXR.UI;
using RepoXR.UI.Controls;
using RepoXR.UI.Expressions;
using RepoXR.UI.Menu;
using RepoXR.UI.Settings;
using Steamworks;
using Steamworks.Data;
using TMPro;
using Unity.XR.CoreUtils;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Experimental.Rendering;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.UI;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.InputSystem.XR;
using UnityEngine.Rendering;
using UnityEngine.Rendering.PostProcessing;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.SceneManagement;
using UnityEngine.Scripting;
using UnityEngine.Serialization;
using UnityEngine.UI;
using UnityEngine.XR;
using UnityEngine.XR.Interaction.Toolkit;
using UnityEngine.XR.Interaction.Toolkit.UI;
using UnityEngine.XR.Management;
using UnityEngine.XR.OpenXR;
using UnityEngine.XR.OpenXR.Features;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("DaXcess")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) DaXcess 2026")]
[assembly: AssemblyDescription("Collecting Valuables in VR")]
[assembly: AssemblyFileVersion("1.2.2.0")]
[assembly: AssemblyInformationalVersion("1.2.2+b9a820e6a3701d416b6134275db93f484314aa13")]
[assembly: AssemblyProduct("RepoXR")]
[assembly: AssemblyTitle("RepoXR")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/DaXcess/RepoXR")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

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

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		((ICollection<T>)_items).CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NativeIntegerAttribute : Attribute
	{
		public readonly bool[] TransformFlags;

		public NativeIntegerAttribute()
		{
			TransformFlags = new bool[1] { true };
		}

		public NativeIntegerAttribute(bool[] P_0)
		{
			TransformFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class ExtensionMarkerAttribute : Attribute
	{
		private readonly string <Name>k__BackingField;

		public string Name => <Name>k__BackingField;

		public ExtensionMarkerAttribute(string name)
		{
			<Name>k__BackingField = name;
		}
	}
}
namespace RepoXR
{
	public static class Compat
	{
		public const string UnityExplorer = "com.sinai.unityexplorer";

		public const string CustomDiscoverStateLib = "Kistras-CustomDiscoverStateLib";

		public static bool IsLoaded(string modId)
		{
			return Chainloader.PluginInfos.ContainsKey(modId);
		}
	}
	public class Config
	{
		public enum HapticFeedbackOption
		{
			Off,
			Reduced,
			All
		}

		public enum TurnProviderOption
		{
			Snap,
			Smooth,
			Disabled
		}

		public string AssemblyPath { get; }

		public ConfigFile File { get; }

		[ConfigDescriptor("Enable VR", false, 1f, 1f, "", "Disable", "Enable", false)]
		public ConfigEntry<bool> DisableVR { get; }

		[ConfigDescriptor(null, false, 1f, 1f, "", "On", "Off", false)]
		public ConfigEntry<bool> VerboseLogging { get; }

		[ConfigDescriptor("VR Prescence", false, 1f, 1f, "", "Hidden", "Shown", false)]
		public ConfigEntry<bool> DisableVRPresence { get; }

		[ConfigDescriptor(null, false, 1f, 1f, "", "On", "Off", false)]
		public ConfigEntry<bool> ReducedAimImpact { get; }

		[ConfigDescriptor(null, false, 1f, 1f, "", "On", "Off", false)]
		public ConfigEntry<bool> RoomscaleCrouch { get; }

		[ConfigDescriptor("Dominant Hand", false, 1f, 1f, "", "Left", "Right", false)]
		public ConfigEntry<bool> LeftHandDominant { get; }

		[ConfigDescriptor("Arms", false, 1f, 1f, "", "Detached", "Attached", false)]
		public ConfigEntry<bool> DetachedArms { get; }

		[ConfigDescriptor(null, false, 1f, 1f, "", "On", "Off", false)]
		public ConfigEntry<HapticFeedbackOption> HapticFeedback { get; }

		[ConfigDescriptor("Eye Tracking", false, 1f, 1f, "", "Enabled", "Disabled", false)]
		public ConfigEntry<bool> EnableEyeTracking { get; }

		[ConfigDescriptor("HUD Height", false, 0.05f, 0.01f, "", "On", "Off", false)]
		public ConfigEntry<float> HUDPlaneOffset { get; }

		[ConfigDescriptor("HUD Secondary Height", false, 0.05f, 0.01f, "", "On", "Off", false)]
		public ConfigEntry<float> HUDGazePlaneOffset { get; }

		[ConfigDescriptor(null, false, 0.25f, 0.05f, "", "On", "Off", false)]
		public ConfigEntry<float> SmoothCanvasDistance { get; }

		[ConfigDescriptor(null, false, 1f, 1f, "", "On", "Off", true)]
		public ConfigEntry<TurnProviderOption> TurnProvider { get; }

		[ConfigDescriptor(null, false, 0.05f, 0.01f, "x", "On", "Off", false)]
		public ConfigEntry<float> SmoothTurnSpeedModifier { get; }

		[ConfigDescriptor(null, false, 1f, 1f, "", "On", "Off", false)]
		public ConfigEntry<bool> AnalogSmoothTurn { get; }

		[ConfigDescriptor(null, false, 5f, 1f, "°", "On", "Off", false)]
		public ConfigEntry<float> SnapTurnSize { get; }

		[ConfigDescriptor(null, false, 1f, 1f, "", "On", "Off", false)]
		public ConfigEntry<bool> NormalizeMovement { get; }

		[ConfigDescriptor("Vehicle direction source", false, 1f, 1f, "", "Head", "Hand", false)]
		public ConfigEntry<bool> VehicleHeadForward { get; }

		[ConfigDescriptor(null, false, 5f, 1f, "%", "On", "Off", false)]
		public ConfigEntry<int> CameraResolution { get; }

		[ConfigDescriptor(null, false, 1f, 1f, "", "On", "Off", false)]
		public ConfigEntry<bool> Vignette { get; }

		[ConfigDescriptor(null, false, 1f, 1f, "", "On", "Off", false)]
		public ConfigEntry<bool> CustomCamera { get; }

		[ConfigDescriptor(null, false, 15f, 5f, "", "On", "Off", false)]
		public ConfigEntry<float> CustomCameraFramerate { get; }

		[ConfigDescriptor(null, false, 5f, 1f, "", "On", "Off", false)]
		public ConfigEntry<float> CustomCameraFOV { get; }

		[ConfigDescriptor(null, true, 0.1f, 0.05f, "", "On", "Off", false)]
		public ConfigEntry<float> CustomCameraSmoothing { get; }

		public ConfigEntry<string> ControllerBindingsOverride { get; }

		public ConfigEntry<string> ControllerBindingsOverrideLeft { get; }

		public ConfigEntry<string> InputToggleBindings { get; }

		public ConfigEntry<string> OpenXRRuntimeFile { get; }

		public Config(string assemblyPath, ConfigFile file)
		{
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Expected O, but got Unknown
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Expected O, but got Unknown
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Expected O, but got Unknown
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Expected O, but got Unknown
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Expected O, but got Unknown
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Expected O, but got Unknown
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Expected O, but got Unknown
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Expected O, but got Unknown
			//IL_0382: Unknown result type (might be due to invalid IL or missing references)
			//IL_038c: Expected O, but got Unknown
			//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c5: Expected O, but got Unknown
			AssemblyPath = assemblyPath;
			File = file;
			DisableVR = file.Create("General", "DisableVR", defaultValue: false, "Disables the main functionality of this mod, can be used if you want to play without VR while keeping the mod installed.");
			VerboseLogging = file.Create("General", "VerboseLogging", defaultValue: false, "Enables verbose debug logging during OpenXR initialization");
			DisableVRPresence = file.Create("General", "DisableVRPresence", defaultValue: false, "Disable the addition of VR status to Discord and Steam prescence.");
			ReducedAimImpact = file.Create("Gameplay", "ReducedAimImpact", defaultValue: false, "When enabled, lowers the severity of force-look events (like the ceiling eye), which can be helpful for people with motion sickness");
			RoomscaleCrouch = file.Create("Gameplay", "RoomscaleCrouch", defaultValue: true, "When enabled, allows for the player to physically crouch to also crouch in-game");
			LeftHandDominant = file.Create("Gameplay", "LeftHandDominant", defaultValue: false, "Whether to use the left or right hand as dominant hand (the hand used to pick up items)");
			DetachedArms = file.Create("Gameplay", "DetachedArms", defaultValue: false, "Whether your arms are attached to your body, or if they are separate");
			HapticFeedback = file.Create("Gameplay", "HapticFeedback", HapticFeedbackOption.All, new ConfigDescription("Controls how much haptic feedback you will experience while playing with the VR mod.", (AcceptableValueBase)(object)new AcceptableValueEnum<HapticFeedbackOption>(), Array.Empty<object>()));
			EnableEyeTracking = file.Create("Gameplay", "EnableEyeTracking", defaultValue: true, "If supported by the headset, use eye tracking to move your characters pupils for other players and for checking line of sight with enemies.");
			HUDPlaneOffset = file.Create("UI", "HUDPlaneOffset", -0.45f, new ConfigDescription("The default height offset for the HUD", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-1f, 0.5f), Array.Empty<object>()));
			HUDGazePlaneOffset = file.Create("UI", "HUDGazePlaneOffset", -0.25f, new ConfigDescription("The height offset for the HUD when looking at it", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-1f, 0.5f), Array.Empty<object>()));
			SmoothCanvasDistance = file.Create("UI", "SmoothCanvasDistance", 1.5f, new ConfigDescription("The distance that the smooth canvas should be away from the main camera", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1.25f, 3f), Array.Empty<object>()));
			TurnProvider = file.Create("Input", "TurnProvider", TurnProviderOption.Smooth, new ConfigDescription("Specify which turning provider your player uses, if any.", (AcceptableValueBase)(object)new AcceptableValueEnum<TurnProviderOption>(), Array.Empty<object>()));
			SmoothTurnSpeedModifier = file.Create("Input", "SmoothTurnSpeedModifier", 1f, new ConfigDescription("A multiplier that is added to the smooth turning speed. Requires turn provider to be set to smooth.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 5f), Array.Empty<object>()));
			AnalogSmoothTurn = file.Create("Input", "AnalogSmoothTurn", defaultValue: true, "When enabled, makes the speed of the smooth turning dependent on how far the analog stick is pushed.");
			SnapTurnSize = file.Create("Input", "SnapTurnSize", 45f, new ConfigDescription("The amount of rotation that is applied when performing a snap turn. Requires turn provider to be set to snap.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(10f, 180f), Array.Empty<object>()));
			NormalizeMovement = file.Create("Input", "NormalizeMovement", defaultValue: false, "When enabled, any direction you move in will always be at full speed, even when the stick is only pushed slightly.");
			VehicleHeadForward = file.Create("Input", "VehicleHeadForward", defaultValue: false, "When enabled, will make the scooters go forward based on head rotation instead of hand rotation.");
			CameraResolution = file.Create("Rendering", "CameraResolution", 100, new ConfigDescription("This setting configures the resolution scale of the game, lower values are more performant, but will make the game look worse.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(5, 200), Array.Empty<object>()));
			Vignette = file.Create("Rendering", "Vignette", defaultValue: true, "Enables the vignette shader used in certain scenarios and levels in the game.");
			CustomCamera = file.Create("Rendering", "CustomCamera", defaultValue: false, "Adds a second camera mounted on top of the VR camera that will render separately from the VR camera to the display. This requires extra GPU power!");
			CustomCameraFramerate = file.Create("Rendering", "CustomCameraFramerate", 144f, new ConfigDescription("The maximum frequency that the custom camera can render at. The custom camera framerate is limited to the VR headset's refresh rate, so setting this higher won't have any effect.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(15f, 144f), Array.Empty<object>()));
			CustomCameraFOV = file.Create("Rendering", "CustomCameraFOV", 75f, new ConfigDescription("The field of view that the custom camera should have.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(45f, 120f), Array.Empty<object>()));
			CustomCameraSmoothing = file.Create("Rendering", "CustomCameraSmoothing", 0.5f, new ConfigDescription("The amount of smoothing that is applied to the custom camera.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			ControllerBindingsOverride = file.Create("Internal", "ControllerBindingsOverride", "", "FOR INTERNAL USE ONLY, DO NOT EDIT");
			ControllerBindingsOverrideLeft = file.Create("Internal", "ControllerBindingsOverrideLeft", "", "FOR INTERNAL USE ONLY, DO NOT EDIT");
			InputToggleBindings = file.Create("Internal", "InputToggleBindings", "", "FOR INTERNAL USE ONLY, DO NOT EDIT");
			OpenXRRuntimeFile = file.Create("Internal", "OpenXRRuntimeFile", "", "FOR INTERNAL USE ONLY, DO NOT EDIT");
			base..ctor();
		}

		public void SetupGlobalCallbacks()
		{
			CameraResolution.SettingChanged += delegate
			{
				XRSettings.eyeTextureResolutionScale = (float)CameraResolution.Value / 100f;
			};
			CustomCamera.SettingChanged += delegate
			{
				if (VRSession.InVR)
				{
					if (CustomCamera.Value)
					{
						Object.Instantiate<GameObject>(AssetCollection.CustomCamera, ((Component)Camera.main).transform.parent);
					}
					else
					{
						Object.Destroy((Object)(object)((Component)VRCustomCamera.instance).gameObject);
					}
				}
			};
			DisableVRPresence.SettingChanged += delegate
			{
				if (VRSession.InVR)
				{
					RunManager instance = RunManager.instance;
					if (instance != null)
					{
						instance.UpdateSteamRichPresence();
					}
				}
			};
		}
	}
	internal class AcceptableValueEnum<T> : AcceptableValueBase where T : Enum
	{
		private readonly string[] names = Enum.GetNames(typeof(T));

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

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

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

		public override string ToDescriptionString()
		{
			return "# Acceptable values: " + string.Join(", ", names);
		}
	}
	[AttributeUsage(AttributeTargets.Property)]
	public class ConfigDescriptorAttribute : Attribute
	{
		[CompilerGenerated]
		private string? <customName>P;

		[CompilerGenerated]
		private bool <percentage>P;

		[CompilerGenerated]
		private float <stepSize>P;

		[CompilerGenerated]
		private float <pointerSize>P;

		[CompilerGenerated]
		private string <suffix>P;

		[CompilerGenerated]
		private string <trueText>P;

		[CompilerGenerated]
		private string <falseText>P;

		[CompilerGenerated]
		private bool <enumDisableBar>P;

		public string? CustomName => <customName>P;

		public bool Percentage => <percentage>P;

		public float StepSize => <stepSize>P;

		public float PointerSize => <pointerSize>P;

		public string Suffix => <suffix>P;

		public string TrueText => <trueText>P;

		public string FalseText => <falseText>P;

		public bool EnumDisableBar => <enumDisableBar>P;

		public ConfigDescriptorAttribute(string? customName = null, bool percentage = false, float stepSize = 1f, float pointerSize = 1f, string suffix = "", string trueText = "On", string falseText = "Off", bool enumDisableBar = false)
		{
			<customName>P = customName;
			<percentage>P = percentage;
			<stepSize>P = stepSize;
			<pointerSize>P = pointerSize;
			<suffix>P = suffix;
			<trueText>P = trueText;
			<falseText>P = falseText;
			<enumDisableBar>P = enumDisableBar;
			base..ctor();
		}
	}
	internal static class ConfigExtensions
	{
		[SpecialName]
		public sealed class <G>$B12CDF11896C5C4C15CE4BB252F1BD5B
		{
			[SpecialName]
			public static class <M>$037C64F40E5FD1BCD853070F004509B4
			{
			}

			[ExtensionMarker("<M>$037C64F40E5FD1BCD853070F004509B4")]
			internal ConfigEntry<T> Create<T>(string section, string key, T defaultValue, string description)
			{
				throw new NotSupportedException();
			}

			[ExtensionMarker("<M>$037C64F40E5FD1BCD853070F004509B4")]
			internal ConfigEntry<T> Create<T>(string section, string key, T defaultValue, ConfigDescription description)
			{
				throw new NotSupportedException();
			}
		}

		internal static ConfigEntry<T> Create<T>(this ConfigFile file, string section, string key, T defaultValue, string description) where T : notnull
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			return file.Bind<T>(section, key, defaultValue, new ConfigDescription(description, (AcceptableValueBase)null, new object[1] { "HideFromREPOConfig" }));
		}

		internal static ConfigEntry<T> Create<T>(this ConfigFile file, string section, string key, T defaultValue, ConfigDescription description) where T : notnull
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			string description2 = description.Description;
			AcceptableValueBase acceptableValues = description.AcceptableValues;
			object obj = "HideFromREPOConfig";
			object[] tags = description.Tags;
			int num = 0;
			object[] array = new object[1 + tags.Length];
			array[num] = obj;
			num++;
			ReadOnlySpan<object> readOnlySpan = new ReadOnlySpan<object>(tags);
			readOnlySpan.CopyTo(new Span<object>(array).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			return file.Bind<T>(section, key, defaultValue, new ConfigDescription(description2, acceptableValues, array));
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class Entrypoint
	{
		internal static void SetupDefaultSceneVR()
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			((Behaviour)GameObject.Find("UI/UI/Canvas").GetComponent<Canvas>()).enabled = false;
			Transform transform = GameObject.Find("UI/HUD/HUD Canvas").transform;
			Transform val = transform.Find("Fade");
			Transform val2 = transform.Find("Render Texture Video");
			Transform val3 = transform.Find("Loading");
			Transform val4 = transform.Find("Moon UI");
			Transform val5 = transform.Find("Splash Screen");
			Transform val6 = transform.Find("Result Screen");
			Camera component = ((Component)transform.parent.Find("Camera Overlay")).GetComponent<Camera>();
			Camera main = Camera.main;
			((Component)main).gameObject.AddComponent<VRCameraTracker>();
			((Component)component).transform.SetParent(((Component)main).transform, false);
			((Component)component).transform.localPosition = Vector3.zero;
			component.depth = 2f;
			component.farClipPlane = 1000f;
			component.orthographic = false;
			component.clearFlags = (CameraClearFlags)3;
			component.targetTexture = null;
			component.nearClipPlane = 0.01f;
			Object.Destroy((Object)(object)((Component)component).GetComponent<PostProcessLayer>());
			main.targetTexture = null;
			Canvas val7 = new GameObject("VR Overlay Canvas")
			{
				layer = 5
			}.AddComponent<Canvas>();
			val7.renderMode = (RenderMode)1;
			val7.worldCamera = component;
			val7.sortingOrder = 5;
			val.SetParent(((Component)val7).transform, false);
			val2.SetParent(((Component)val7).transform, false);
			((Graphic)((Component)val2).GetComponent<RawImage>()).material = AssetCollection.VideoOverlay;
			CollectionExtensions.Do<RectTransform>((IEnumerable<RectTransform>)((Component)((Component)val7).transform).GetComponentsInChildren<RectTransform>(true), (Action<RectTransform>)delegate(RectTransform rect)
			{
				//IL_0001: 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)
				rect.anchorMin = Vector2.zero;
				rect.anchorMax = Vector2.one;
			});
			Canvas val8 = new GameObject("VR Loading Canvas")
			{
				layer = 5
			}.AddComponent<Canvas>();
			val8.renderMode = (RenderMode)2;
			val8.sortingOrder = 6;
			((Component)val8).transform.localPosition = Vector3.zero;
			((Component)val8).transform.localEulerAngles = Vector3.zero;
			((Component)val8).transform.localScale = Vector3.one * 0.01f;
			((Component)val8).transform.SetParent(((Component)Camera.main).transform.parent, false);
			((Component)val8).gameObject.AddComponent<LoadingUI>();
			((Component)val8).GetComponent<RectTransform>().sizeDelta = new Vector2(720f, 400f);
			val3.SetParent(((Component)val8).transform, false);
			GameObject val9 = new GameObject("Moon Mask");
			val9.transform.parent = ((Component)val8).transform;
			val9.transform.localScale = Vector3.one;
			val9.transform.localPosition = Vector3.zero;
			val9.transform.localRotation = Quaternion.identity;
			RectTransform component2 = ((Component)val9.AddComponent<RectMask2D>()).GetComponent<RectTransform>();
			component2.sizeDelta = new Vector2(800f, 550f);
			val4.SetParent(((Component)component2).transform, false);
			val4.localScale = Vector3.one * 0.8f;
			GameObject val10 = new GameObject("Result Mask");
			val10.transform.parent = ((Component)val8).transform;
			val10.transform.localScale = Vector3.one;
			val10.transform.localPosition = Vector3.zero;
			val10.transform.localRotation = Quaternion.identity;
			RectTransform component3 = ((Component)val10.AddComponent<RectMask2D>()).GetComponent<RectTransform>();
			component3.sizeDelta = new Vector2(720f, 405f);
			val6.SetParent(((Component)component3).transform, false);
			val5.SetParent(((Component)val8).transform, false);
			val5.SetAsFirstSibling();
			if (Plugin.Config.CustomCamera.Value)
			{
				Object.Instantiate<GameObject>(AssetCollection.CustomCamera, ((Component)Camera.main).transform.parent);
			}
			new GameObject("Haptic Manager").AddComponent<HapticManager>();
			new GameObject("Data Manager").AddComponent<DataManager>();
		}

		[HarmonyPatch(typeof(GameDirector), "Start")]
		[HarmonyPostfix]
		private static void OnStartup(GameDirector __instance)
		{
			VRInputSystem.Instance.ActivateInput();
			if ((Object)(object)RunManager.instance.levelCurrent == (Object)(object)RunManager.instance.levelMainMenu || (Object)(object)RunManager.instance.levelCurrent == (Object)(object)RunManager.instance.levelSplashScreen)
			{
				OnStartupMainMenu();
			}
		}

		[HarmonyPatch(typeof(LobbyMenuOpen), "Awake")]
		[HarmonyPostfix]
		private static void OnStartLobbyMenu()
		{
			if ((Object)(object)RunManager.instance.levelCurrent == (Object)(object)RunManager.instance.levelLobbyMenu)
			{
				OnStartupMainMenu();
			}
		}

		[HarmonyPatch(typeof(StartRoom), "Start")]
		[HarmonyPostfix]
		private static void OnStartTruck(StartRoom __instance)
		{
			bool flag;
			switch (((Object)__instance).name)
			{
			case "Start Room - Main Menu(Clone)":
			case "Start Room - Lobby Menu(Clone)":
			case "Start Room - Splash Screen(Clone)":
				flag = true;
				break;
			default:
				flag = false;
				break;
			}
			if (!flag)
			{
				OnStartupInGame();
			}
		}

		[HarmonyPatch(typeof(SplashScreen), "Start")]
		[HarmonyPostfix]
		private static void OnStartupSplashScreen()
		{
			LoadingUI.instance.ResetPosition();
		}

		private static void OnStartupMainMenu()
		{
			((Component)HUDCanvas.instance).gameObject.AddComponent<MainMenu>();
			DataManager.instance.ResetData();
		}

		private static void OnStartupInGame()
		{
			((Component)GameDirector.instance).gameObject.AddComponent<VRSession>();
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.Universal, null)]
	internal static class UniversalEntrypoint
	{
		private static bool hasShownErrorMessage;

		public static void OnSceneLoad(string _)
		{
			if (Plugin.Flags.HasFlag(Flags.VR))
			{
				Entrypoint.SetupDefaultSceneVR();
			}
			SetupDefaultSceneUniversal();
		}

		private static void SetupDefaultSceneUniversal()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			new GameObject("RepoXR Network System").AddComponent<NetworkSystem>();
			ShowVRFailedWarning();
		}

		private static void ShowVRFailedWarning()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.Flags.HasFlag(Flags.StartupFailed) && !hasShownErrorMessage && !((Object)(object)RunManager.instance.levelCurrent != (Object)(object)RunManager.instance.levelMainMenu))
			{
				hasShownErrorMessage = true;
				MenuManager.instance.PagePopUpScheduled("VR Startup Failed", Color.red, "RepoXR tried to launch the game in VR, however an error occured during initialization.\n\nYou will still be able to play the game and make use of this mod's features, however you will not be in VR.\n\nYou can disable VR in the settings if you want to suppress this error in the future.", "Alright fam", true);
			}
		}
	}
	public static class Logger
	{
		internal static ManualLogSource? source;

		public static void LogInfo(object message)
		{
			ManualLogSource? obj = source;
			if (obj != null)
			{
				obj.LogInfo(message);
			}
		}

		public static void LogWarning(object message)
		{
			ManualLogSource? obj = source;
			if (obj != null)
			{
				obj.LogWarning(message);
			}
		}

		public static void LogError(object message)
		{
			ManualLogSource? obj = source;
			if (obj != null)
			{
				obj.LogError(message);
			}
		}

		public static void LogDebug(object message)
		{
			ManualLogSource? obj = source;
			if (obj != null)
			{
				obj.LogDebug(message);
			}
		}
	}
	internal static class Native
	{
		private delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);

		private struct SID_AND_ATTRIBUTES
		{
			public IntPtr Sid;

			public uint Attributes;
		}

		private struct TOKEN_MANDATORY_LABEL
		{
			public SID_AND_ATTRIBUTES Label;
		}

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

		private const int SECURITY_MAX_SID_SIZE = 68;

		[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 IntPtr GetForegroundWindow();

		[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
		public static extern IntPtr GetModuleHandle(string lpModuleName);

		[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, in byte lpData, int tokenInformationLength, out uint returnLength);

		[DllImport("advapi32.dll", SetLastError = true)]
		private static extern IntPtr GetSidSubAuthorityCount(IntPtr pSid);

		[DllImport("advapi32.dll", SetLastError = true)]
		private static extern IntPtr GetSidSubAuthority(IntPtr pSid, int nSubAuthority);

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

		public static bool IsHighIntegrityLevel()
		{
			IntPtr hToken = IntPtr.Zero;
			try
			{
				if (!OpenProcessToken(GetCurrentProcess(), 24u, out hToken))
				{
					return false;
				}
				Span<byte> span = stackalloc byte[72];
				if (!GetTokenInformation(hToken, 25u, in MemoryMarshal.GetReference(span), span.Length, out var _))
				{
					return false;
				}
				IntPtr sid = MemoryMarshal.Cast<byte, TOKEN_MANDATORY_LABEL>(span)[0].Label.Sid;
				if (sid == IntPtr.Zero)
				{
					return false;
				}
				byte b = Marshal.ReadByte(GetSidSubAuthorityCount(sid));
				return Marshal.ReadInt32(GetSidSubAuthority(sid, b - 1)) > 8192;
			}
			finally
			{
				if (hToken != IntPtr.Zero)
				{
					CloseHandle(hToken);
				}
			}
		}

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

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

		private static IEnumerable<IntPtr> FindWindows(EnumWindowsProc filter)
		{
			EnumWindowsProc filter2 = filter;
			List<IntPtr> windows = new List<IntPtr>();
			EnumWindows(delegate(IntPtr hWnd, IntPtr lParam)
			{
				if (filter2(hWnd, lParam))
				{
					windows.Add(hWnd);
				}
				return true;
			}, IntPtr.Zero);
			return windows;
		}
	}
	internal static class OpenXR
	{
		public class Runtimes : IReadOnlyCollection<Runtime>, IEnumerable<Runtime>, IEnumerable
		{
			[CompilerGenerated]
			private Runtime[] <runtimes>P;

			public Runtime? Default;

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

			public Runtimes(Runtime[] runtimes)
			{
				<runtimes>P = runtimes;
				Default = ((IEnumerable<Runtime>)<runtimes>P).Select((Func<Runtime, Runtime?>)((Runtime rt) => rt)).FirstOrDefault((Runtime? rt) => rt.Value.Default);
				base..ctor();
			}

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

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

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

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

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

			public string Path { get; set; }

			public bool Default { get; set; }

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

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

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

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

		public static class Loader
		{
			private static XRGeneralSettings? xrGeneralSettings;

			private static XRManagerSettings? xrManagerSettings;

			private static OpenXRLoader? xrLoader;

			private static readonly ManualLogSource Logger;

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

			public static bool InitializeXR()
			{
				InitializeScripts();
				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 RepoXR was not installed correctly.");
					return false;
				}
				if (Native.IsHighIntegrityLevel())
				{
					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 default behavior.");
					Runtime? runtime;
					if (!string.IsNullOrEmpty(Plugin.Config.OpenXRRuntimeFile.Value))
					{
						Runtime value = default(Runtime);
						value.Name = "RepoXR OpenXR Override";
						value.Path = Plugin.Config.OpenXRRuntimeFile.Value;
						runtime = value;
					}
					else
					{
						runtime = null;
					}
					return InitializeXR(runtime);
				}
				if (!string.IsNullOrEmpty(Plugin.Config.OpenXRRuntimeFile.Value))
				{
					Runtime value2;
					if (!runtimes.TryGetRuntimeByPath(Plugin.Config.OpenXRRuntimeFile.Value, out var runtime2))
					{
						Runtime value = default(Runtime);
						value.Name = "RepoXR OpenXR Override";
						value.Path = Plugin.Config.OpenXRRuntimeFile.Value;
						value2 = value;
					}
					else
					{
						value2 = runtime2;
					}
					if (InitializeXR(value2))
					{
						return true;
					}
					Logger.LogWarning((object)"Loading OpenXR using override failed, falling back to automatic enumeration...");
				}
				Runtime? @default = runtimes.Default;
				if (@default.HasValue)
				{
					Runtime valueOrDefault = @default.GetValueOrDefault();
					if (valueOrDefault.Path != Plugin.Config.OpenXRRuntimeFile.Value && InitializeXR(valueOrDefault))
					{
						return true;
					}
				}
				foreach (Runtime item in runtimes.Where((Runtime rt) => rt.Path != Plugin.Config.OpenXRRuntimeFile.Value && !rt.Default))
				{
					if (InitializeXR(item))
					{
						return true;
					}
				}
				Logger.LogError((object)"All available runtimes were attempted, but none worked. Aborting...");
				return false;
			}

			private static bool InitializeXR(Runtime? runtime)
			{
				if ((Object)(object)xrManagerSettings == (Object)null || (Object)(object)xrGeneralSettings == (Object)null || (Object)(object)xrLoader == (Object)null)
				{
					return false;
				}
				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.VerboseLogging.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 diagnostic reports from being printed, disable the 'VerboseLogging' 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.features = AssetCollection.OpenXRFeatures.Features.ToArray();
			}
		}

		[CompilerGenerated]
		private sealed class <LocateCommonRuntimes>d__8 : IEnumerable<Runtime>, IEnumerable, IEnumerator<Runtime>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private Runtime <>2__current;

			private int <>l__initialThreadId;

			Runtime IEnumerator<Runtime>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <LocateCommonRuntimes>d__8(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				Runtime runtime2;
				string path;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					Runtime? runtime = Utils.ExecuteWithSteamAPI((Func<Runtime?>)delegate
					{
						//IL_0005: Unknown result type (might be due to invalid IL or missing references)
						//IL_0016: Unknown result type (might be due to invalid IL or missing references)
						if (SteamApps.IsAppInstalled(AppId.op_Implicit(250820)))
						{
							string text = SteamApps.AppInstallDir(AppId.op_Implicit(250820));
							if (text != null && Runtime.ReadFromJson(Path.Combine(text, "steamxr_win64.json"), out var runtime3))
							{
								return runtime3;
							}
						}
						return null;
					});
					if (runtime.HasValue)
					{
						<>2__current = runtime.Value;
						<>1__state = 1;
						return true;
					}
					goto IL_0071;
				}
				case 1:
					<>1__state = -1;
					goto IL_0071;
				case 2:
					<>1__state = -1;
					goto IL_00ac;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_00ac:
					path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "Oculus\\Support\\oculus-runtime\\oculus_openxr_64.json");
					if (File.Exists(path) && Runtime.ReadFromJson(path, out runtime2))
					{
						<>2__current = runtime2;
						<>1__state = 3;
						return true;
					}
					break;
					IL_0071:
					path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "Virtual Desktop Streamer\\OpenXR\\virtualdesktop-openxr.json");
					if (File.Exists(path) && Runtime.ReadFromJson(path, out runtime2))
					{
						<>2__current = runtime2;
						<>1__state = 2;
						return true;
					}
					goto IL_00ac;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<Runtime> IEnumerable<Runtime>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <LocateCommonRuntimes>d__8(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<Runtime>)this).GetEnumerator();
			}
		}

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

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

		[DllImport("UnityOpenXR", EntryPoint = "NativeConfig_GetRuntimeName")]
		private static extern bool Internal_GetRuntimeName(out nint 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()
		{
			nint num = Internal_GenerateReport();
			if (num == 0)
			{
				return "";
			}
			string result = Marshal.PtrToStringAnsi(num);
			Internal_ReleaseReport(num);
			return result;
		}

		public static Runtimes GetRuntimes()
		{
			HashSet<Runtime> hashSet = new HashSet<Runtime>();
			foreach (Runtime item in LocateCommonRuntimes())
			{
				hashSet.Add(item);
			}
			string defaultRuntimePath = GetDefaultRuntimePath();
			if (Native.RegOpenKeyEx(Native.HKEY_LOCAL_MACHINE, "SOFTWARE\\Khronos\\OpenXR\\1", 0, 131097, out nint 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"];
					hashSet.Add(new Runtime
					{
						Name = val[(object)"name"].ToObject<string>(),
						Path = defaultRuntimePath,
						Default = true
					});
				}
				catch
				{
				}
				return new Runtimes(hashSet.ToArray());
			}
			if (!string.IsNullOrEmpty(defaultRuntimePath) && !list.Contains(defaultRuntimePath))
			{
				list.Add(defaultRuntimePath);
			}
			foreach (string item2 in list)
			{
				try
				{
					JToken val2 = JsonConvert.DeserializeObject<JToken>(File.ReadAllText(item2))[(object)"runtime"];
					hashSet.Add(new Runtime
					{
						Name = val2[(object)"name"].ToObject<string>(),
						Path = item2,
						Default = (item2 == defaultRuntimePath)
					});
				}
				catch (Exception ex)
				{
					Logger.LogWarning("Failed to parse " + item2 + ": " + ex.Message + ". Runtime will be skipped.");
				}
			}
			return new Runtimes(hashSet.ToArray());
		}

		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;
			if (!flag)
			{
				bool flag2 = lpType - 1 <= 1;
				flag = !flag2;
			}
			if (flag)
			{
				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(nint 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++)
			{
				uint lpcchValueName = lpcbMaxValueNameLen + 1;
				StringBuilder stringBuilder = new StringBuilder((int)lpcchValueName);
				if (Native.RegEnumValue(hKey, num, stringBuilder, ref lpcchValueName, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero) == 0)
				{
					files.Add(stringBuilder.ToString());
				}
			}
			return true;
		}

		[IteratorStateMachine(typeof(<LocateCommonRuntimes>d__8))]
		private static IEnumerable<Runtime> LocateCommonRuntimes()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LocateCommonRuntimes>d__8(-2);
		}

		public static bool GetActiveRuntimeName(out string name)
		{
			name = "";
			if (!Internal_GetRuntimeName(out IntPtr runtimeNamePtr) || runtimeNamePtr == (IntPtr)0)
			{
				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);
		}
	}
	[PublicAPI]
	[BepInPlugin("io.daxcess.repoxr", "RepoXR", "1.2.2")]
	public class Plugin : BaseUnityPlugin
	{
		public const string PLUGIN_GUID = "io.daxcess.repoxr";

		public const string PLUGIN_NAME = "RepoXR";

		public const string PLUGIN_VERSION = "1.2.2";

		public const string SUPPORTED_GAME_VERSION = "v0.4.3";

		public static Config Config { get; private set; }

		public static Flags Flags { get; private set; }

		public static string GameVersion => Environment.GetEnvironmentVariable("REPO_VERSION") ?? "v?";

		public static bool GameDebugBuild
		{
			get
			{
				if (!Environment.GetCommandLineArgs().Contains("--repoxr-force-release-build"))
				{
					return Debug.isDebugBuild;
				}
				return false;
			}
		}

		private void Awake()
		{
			CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
			InputSystem.PerformDefaultPluginInitialization();
			Logger.source = ((BaseUnityPlugin)this).Logger;
			Config = new Config(((BaseUnityPlugin)this).Info.Location, ((BaseUnityPlugin)this).Config);
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Starting RepoXR v1.2.2 (" + GetCommitHash() + ")"));
			bool flag = Config.DisableVR.Value || Environment.GetCommandLineArgs().Contains<string>("--disable-vr", StringComparer.OrdinalIgnoreCase);
			if (flag)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"VR has been disabled by config or the `--disable-vr` command line flag");
			}
			if (!PreloadRuntimeDependencies())
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"Disabling mod because required runtime dependencies could not be loaded!");
				return;
			}
			if (!AssetCollection.LoadAssets())
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"Disabling mod because assets could not be loaded!");
				return;
			}
			if (!flag && InitializeVR())
			{
				Flags |= Flags.VR;
			}
			HarmonyPatcher.PatchUniversal();
			HarmonyPatcher.PatchNetworkRPCs();
			((BaseUnityPlugin)this).Logger.LogDebug((object)"Inserted universal patches using Harmony");
			if (Environment.GetCommandLineArgs().Contains<string>("--repoxr-debug-eyetracking", StringComparer.OrdinalIgnoreCase))
			{
				Flags |= Flags.EyeTrackingDebug;
			}
			Native.BringGameWindowToFront();
			Config.SetupGlobalCallbacks();
			SceneManager.sceneLoaded += delegate(Scene scene, LoadSceneMode _)
			{
				UniversalEntrypoint.OnSceneLoad(((Scene)(ref scene)).name);
			};
		}

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

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

		private static bool InitializeVR()
		{
			Logger.LogInfo("Loading VR...");
			if (!OpenXR.Loader.InitializeXR())
			{
				Logger.LogError("Failed to start in VR Mode! Only Non-VR features are available!");
				Logger.LogError("Make sure your headset is turned on and connected before starting the game.");
				Logger.LogWarning("You may ignore the previous error if you meant to play without VR");
				Flags |= Flags.StartupFailed;
				return false;
			}
			if (OpenXR.GetActiveRuntimeName(out string name) && OpenXR.GetActiveRuntimeVersion(out var major, out var minor, out var patch))
			{
				Logger.LogInfo($"OpenXR runtime being used: {name} ({major}.{minor}.{patch})");
			}
			else
			{
				Logger.LogError("Could not get OpenXR runtime info?");
			}
			HarmonyPatcher.PatchVR();
			Logger.LogDebug("Inserted VR patches using Harmony");
			XRSettings.eyeTextureResolutionScale = (float)Config.CameraResolution.Value / 100f;
			InputSystem.settings.backgroundBehavior = (BackgroundBehavior)2;
			return true;
		}

		public static MethodInfo GetConfigGetter()
		{
			return typeof(Plugin).GetProperty("Config", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).GetGetMethod(nonPublic: true);
		}
	}
	[Flags]
	public enum Flags
	{
		VR = 1,
		StartupFailed = 2,
		EyeTrackingDebug = 4
	}
	internal static class Utils
	{
		public class WaitUntilTimeout : CustomYieldInstruction
		{
			[CompilerGenerated]
			private Func<bool> <predicate>P;

			[CompilerGenerated]
			private float <timeout>P;

			private readonly float timeStarted;

			public override bool keepWaiting
			{
				get
				{
					if (!<predicate>P())
					{
						return Time.realtimeSinceStartup - timeStarted < <timeout>P;
					}
					return false;
				}
			}

			public WaitUntilTimeout(Func<bool> predicate, float timeout)
			{
				<predicate>P = predicate;
				<timeout>P = timeout;
				timeStarted = Time.realtimeSinceStartup;
				((CustomYieldInstruction)this)..ctor();
			}
		}

		public static string ToHumanReadable(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 string GetControlSpriteString(string controlPath)
		{
			if (string.IsNullOrEmpty(controlPath))
			{
				return "<b><u>NOT BOUND</u></b>";
			}
			string text = Regex.Replace(controlPath.ToLowerInvariant(), "<[^>]+>([^ ]+)", "$1");
			string text2 = text.Split('/')[0].TrimStart('{').TrimEnd('}');
			controlPath = Regex.Replace(string.Join("/", text.Split('/').Skip(1)), "{(.*)}", "$1");
			if (!(text2 == "lefthand"))
			{
				if (text2 == "righthand")
				{
					switch (controlPath)
					{
					case "primary2daxis":
					case "thumbstick":
						goto IL_07a8;
					case "primary2daxisclick":
					case "thumbstickclicked":
						goto IL_07b0;
					case "thumbstick/up":
					case "primary2daxis/up":
						goto IL_07b8;
					case "primary2daxis/down":
					case "thumbstick/down":
						goto IL_07c0;
					case "primary2daxis/left":
					case "thumbstick/left":
						goto IL_07c8;
					case "thumbstick/right":
					case "primary2daxis/right":
						goto IL_07d0;
					case "primarybutton":
					case "primarypressed":
						goto IL_07d8;
					case "secondarypressed":
					case "secondarybutton":
						goto IL_07e0;
					case "triggerbutton":
					case "triggerpressed":
					case "trigger":
						goto IL_07e8;
					case "gripbutton":
					case "grip":
					case "grippressed":
						goto IL_07f0;
					}
				}
				switch (controlPath)
				{
				case "menu":
				case "menubutton":
				case "menupressed":
					break;
				default:
					goto IL_0800;
				}
				goto IL_07f8;
			}
			switch (controlPath)
			{
			case "thumbstick":
			case "primary2daxis":
				break;
			case "primary2daxisclick":
			case "thumbstickclicked":
				goto IL_0754;
			case "thumbstick/up":
			case "primary2daxis/up":
				goto IL_075f;
			case "primary2daxis/down":
			case "thumbstick/down":
				goto IL_076a;
			case "primary2daxis/left":
			case "thumbstick/left":
				goto IL_0775;
			case "thumbstick/right":
			case "primary2daxis/right":
				goto IL_0780;
			case "primarybutton":
			case "primarypressed":
				goto IL_0788;
			case "secondarypressed":
			case "secondarybutton":
				goto IL_0790;
			case "triggerbutton":
			case "triggerpressed":
			case "trigger":
				goto IL_0798;
			case "grip":
			case "gripbutton":
			case "grippressed":
				goto IL_07a0;
			case "menu":
			case "menubutton":
			case "menupressed":
				goto IL_07f8;
			default:
				goto IL_0800;
			}
			string text3 = "leftStick";
			goto IL_0806;
			IL_0780:
			text3 = "leftStickRight";
			goto IL_0806;
			IL_0775:
			text3 = "leftStickLeft";
			goto IL_0806;
			IL_076a:
			text3 = "leftStickDown";
			goto IL_0806;
			IL_0806:
			string text4 = text3;
			return "<sprite name=\"" + text4 + "\">";
			IL_07f0:
			text3 = "rightGrip";
			goto IL_0806;
			IL_07e8:
			text3 = "rightTrigger";
			goto IL_0806;
			IL_07e0:
			text3 = "rightSecondaryButton";
			goto IL_0806;
			IL_07d8:
			text3 = "rightPrimaryButton";
			goto IL_0806;
			IL_07d0:
			text3 = "rightStickRight";
			goto IL_0806;
			IL_07c8:
			text3 = "rightStickLeft";
			goto IL_0806;
			IL_07c0:
			text3 = "rightStickDown";
			goto IL_0806;
			IL_07b8:
			text3 = "rightStickUp";
			goto IL_0806;
			IL_07b0:
			text3 = "rightStickClick";
			goto IL_0806;
			IL_07a8:
			text3 = "rightStick";
			goto IL_0806;
			IL_0754:
			text3 = "leftStickClick";
			goto IL_0806;
			IL_075f:
			text3 = "leftStickUp";
			goto IL_0806;
			IL_0800:
			text3 = "unknown";
			goto IL_0806;
			IL_07f8:
			text3 = "menuButton";
			goto IL_0806;
			IL_07a0:
			text3 = "leftGrip";
			goto IL_0806;
			IL_0798:
			text3 = "leftTrigger";
			goto IL_0806;
			IL_0790:
			text3 = "leftSecondaryButton";
			goto IL_0806;
			IL_0788:
			text3 = "leftPrimaryButton";
			goto IL_0806;
		}

		public static bool GetControlHand(string controlPath, out HapticManager.Hand hand)
		{
			hand = HapticManager.Hand.Both;
			if (string.IsNullOrEmpty(controlPath))
			{
				return false;
			}
			string text = Regex.Replace(controlPath.ToLowerInvariant(), "<[^>]+>([^ ]+)", "$1").Split('/')[0].TrimStart('{').TrimEnd('}');
			hand = ((!(text == "lefthand")) ? HapticManager.Hand.Right : HapticManager.Hand.Left);
			return true;
		}

		public static T? ExecuteWithSteamAPI<T>(Func<T> func)
		{
			try
			{
				bool isValid = SteamClient.IsValid;
				if (!isValid)
				{
					SteamClient.Init(3241660u, false);
				}
				T result = func();
				if (!isValid)
				{
					SteamClient.Shutdown();
				}
				return result;
			}
			catch
			{
				return default(T);
			}
		}

		public static bool Collide(Collider lhs, params Collider[] rhs)
		{
			Collider lhs2 = lhs;
			Vector3 val = default(Vector3);
			float num = default(float);
			return rhs.Any((Collider collider) => Physics.ComputePenetration(lhs2, ((Component)lhs2).transform.position, ((Component)lhs2).transform.rotation, collider, ((Component)collider).transform.position, ((Component)collider).transform.rotation, ref val, ref num));
		}

		public static void DisableScanlines(this SemiUI ui)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			UIScanlines componentInChildren = ((Component)ui).GetComponentInChildren<UIScanlines>();
			if (componentInChildren != null)
			{
				((Behaviour)componentInChildren).enabled = false;
				((Graphic)componentInChildren.image).color = Color.clear;
			}
		}

		public static void SetUIAnchoredPosition(this SemiUI ui, Vector2 anchoredPosition)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			Vector2 hidePosition = ui.hidePosition - ui.showPosition;
			((Component)ui).GetComponent<RectTransform>().anchoredPosition = anchoredPosition;
			ui.showPosition = Vector2.zero;
			ui.hidePosition = hidePosition;
			ui.Start();
		}

		public static void ReplaceOrInsert<T>(this List<T> list, T item, Predicate<T> match)
		{
			int num = list.FindIndex(match);
			if (num >= 0)
			{
				list[num] = item;
			}
			else
			{
				list.Add(item);
			}
		}

		public static Color GetTextColor(Color baseColor, float minBrightness = 0.6f, float alpha = 1f)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			float num = 0.2126f * baseColor.r + 0.7152f * baseColor.g + 0.0722f * baseColor.b;
			if (num < minBrightness)
			{
				float num2 = Mathf.Clamp01((minBrightness - num) / minBrightness);
				baseColor = Color.Lerp(baseColor, Color.white, num2);
			}
			baseColor.a = alpha;
			return baseColor;
		}

		public static string StripSuffix(this string @string, string suffix)
		{
			if (!@string.EndsWith(suffix))
			{
				return @string;
			}
			int length = suffix.Length;
			return @string.Substring(0, @string.Length - length);
		}

		public static LocalizedAsset L(string name)
		{
			//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)
			return AssetCollection.GetLocalizedAsset(name).WaitForCompletion();
		}
	}
	public static class PlayerLocalCameraExtensions
	{
		public static MethodInfo GetHandOverrideTransformMethod => AccessTools.Method(typeof(PlayerLocalCameraExtensions), "GetHandOverrideTransform", (Type[])null, (Type[])null);

		public static Transform GetHandOverrideTransform(this PlayerLocalCamera camera)
		{
			if (camera.GetOverrideActive())
			{
				return camera.playerAvatar.PlayerVisionTarget.VisionTransform;
			}
			VRSession instance = VRSession.Instance;
			if (instance != null && camera.playerAvatar.isLocal)
			{
				return instance.Player.MainHand;
			}
			if (Object.op_Implicit((Object)(object)NetworkSystem.instance) && NetworkSystem.instance.GetNetworkPlayer(camera.playerAvatar, out NetworkPlayer networkPlayer))
			{
				return networkPlayer.PrimaryHand;
			}
			return ((Component)camera).transform;
		}
	}
	public static class HashExtensions
	{
		private const ulong FNV_OFFSET_BASIS = 12201171901673549955uL;

		private const ulong FNV_PRIME = 7286768417uL;

		private static Dictionary<Type, ulong> typeHashCache = new Dictionary<Type, ulong>();

		private static Dictionary<MethodBase, ulong> methodHashCache = new Dictionary<MethodBase, ulong>();

		public static ulong GetNetworkHash(this Type type)
		{
			if (typeHashCache.TryGetValue(type, out var value))
			{
				return value;
			}
			value = ComputeHash(Encoding.UTF8.GetBytes(TypeExtensions.GetFullNameWithGenericArguments(type)));
			typeHashCache[type] = value;
			return value;
		}

		public static ulong GetNetworkHash(this MethodBase method)
		{
			if (methodHashCache.TryGetValue(method, out var value))
			{
				return value;
			}
			string fullNameWithGenericArguments = TypeExtensions.GetFullNameWithGenericArguments(method.DeclaringType);
			string text = method.Name + "<" + string.Join(", ", from a in method.GetGenericArguments()
				select TypeExtensions.GetFullNameWithGenericArguments(a.DeclaringType)) + ">(" + string.Join(",", from p in method.GetParameters()
				select TypeExtensions.GetFullNameWithGenericArguments(p.ParameterType)) + ")";
			string s = fullNameWithGenericArguments + "::" + text;
			value = ComputeHash(Encoding.UTF8.GetBytes(s));
			methodHashCache[method] = value;
			return value;
		}

		private static ulong ComputeHash(byte[] input)
		{
			ulong num = 12201171901673549955uL;
			foreach (byte b in input)
			{
				num ^= b;
				num *= 7286768417L;
			}
			return num;
		}
	}
}
namespace RepoXR.UI
{
	public class ChatUI : MonoBehaviour
	{
		private ChatManager chatManager;

		private NonNativeKeyboard keyboard;

		private Vector3 keyboardScale;

		private float keyboardLerp;

		private ChatState prevState;

		private void Awake()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			chatManager = ChatManager.instance;
			keyboard = Object.Instantiate<GameObject>(AssetCollection.Keyboard, ((Component)this).transform.TransformPoint(new Vector3(360f, -100f)), ((Component)this).transform.rotation * Quaternion.Euler(15f, 0f, 0f)).GetComponent<NonNativeKeyboard>();
			keyboard.SubmitOnEnter = false;
			keyboard.OnKeyboardValueKeyPressed += OnKeyPressed;
			keyboard.OnKeyboardFunctionKeyPressed += OnFunctionKeyPressed;
			keyboardScale = Vector3.one * (((Object)(object)RunManager.instance.levelCurrent == (Object)(object)RunManager.instance.levelLobbyMenu) ? 0.0175f : 0.005f);
			prevState = chatManager.chatState;
		}

		private void OnDestroy()
		{
			keyboard.OnKeyboardValueKeyPressed -= OnKeyPressed;
			keyboard.OnKeyboardFunctionKeyPressed -= OnFunctionKeyPressed;
		}

		private void Update()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Invalid comparison between Unknown and I4
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Invalid comparison between Unknown and I4
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Invalid comparison between Unknown and I4
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Invalid comparison between Unknown and I4
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Invalid comparison between Unknown and I4
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: 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_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			if (((Behaviour)LoadingUI.instance).isActiveAndEnabled && (int)ChatManager.instance.chatState == 1)
			{
				chatManager.StateSet((ChatState)0);
			}
			if (!SemiFunc.MenuLevel() && Object.op_Implicit((Object)(object)MenuManager.instance.currentMenuPage) && (int)ChatManager.instance.chatState == 1)
			{
				chatManager.StateSet((ChatState)0);
			}
			if (((int)chatManager.chatState == 1 && chatManager.chatState != prevState) || (int)chatManager.chatState == 2)
			{
				PauseUI.instance?.ResetPosition(instant: true);
			}
			if ((Object)(object)RunManager.instance.levelCurrent != (Object)(object)RunManager.instance.levelLobbyMenu)
			{
				if ((int)chatManager.chatState == 1 && chatManager.chatState != prevState)
				{
					XRRayInteractorManager.Instance?.SetVisible(visible: true);
				}
				if ((int)chatManager.chatState != 1 && chatManager.chatState != prevState)
				{
					XRRayInteractorManager.Instance?.SetVisible(visible: false);
				}
			}
			prevState = chatManager.chatState;
			if ((int)chatManager.chatState == 1)
			{
				PhysGrabber.instance.ReleaseObject(-1, 0.1f);
				if (!((Component)keyboard).gameObject.activeSelf)
				{
					keyboard.PresentKeyboard();
				}
				keyboardLerp += 8f * Time.deltaTime;
				keyboardLerp = Mathf.Clamp01(keyboardLerp);
				((Component)keyboard).transform.localScale = Vector3.Slerp(Vector3.zero, keyboardScale, keyboardLerp);
			}
			else if (((Component)keyboard).gameObject.activeSelf)
			{
				keyboardLerp -= 8f * Time.deltaTime;
				keyboardLerp = Mathf.Clamp01(keyboardLerp);
				((Component)keyboard).transform.localScale = Vector3.Slerp(Vector3.zero, keyboardScale, keyboardLerp);
				if (keyboardLerp == 0f)
				{
					keyboard.Close();
				}
			}
		}

		private void LateUpdate()
		{
			//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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			((Component)keyboard).transform.position = ((Component)this).transform.TransformPoint(new Vector3(360f, -100f, 0f));
			((Component)keyboard).transform.rotation = ((Component)this).transform.rotation * Quaternion.Euler(15f, 0f, 0f);
		}

		private void AppendText(string text)
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			string chatMessage = chatManager.chatMessage;
			ChatManager obj = chatManager;
			obj.chatMessage += text;
			if (chatManager.chatMessage.Length > 50)
			{
				((SemiUI)ChatUI.instance).SemiUITextFlashColor(Color.red, 0.2f);
				((SemiUI)ChatUI.instance).SemiUISpringShakeX(10f, 10f, 0.3f);
				((SemiUI)ChatUI.instance).SemiUISpringScale(0.05f, 5f, 0.2f);
				MenuManager.instance.MenuEffectClick((MenuClickEffectType)2, (MenuPage)null, 1f, 1f, true);
				chatManager.chatMessage = chatMessage;
			}
			else
			{
				chatManager.TypeEffect(Color.yellow);
			}
		}

		private void OnKeyPressed(KeyboardValueKey key)
		{
			AppendText(keyboard.IsShifted ? key.ShiftValue : key.Value);
		}

		private void ChatHistoryCycle(bool previous)
		{
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			if (chatManager.chatHistory.Count == 0)
			{
				return;
			}
			if (previous)
			{
				if (chatManager.chatHistoryIndex > 0)
				{
					ChatManager obj = chatManager;
					obj.chatHistoryIndex--;
				}
				else
				{
					chatManager.chatHistoryIndex = chatManager.chatHistory.Count - 1;
				}
			}
			else if (chatManager.chatHistoryIndex < chatManager.chatHistory.Count - 1)
			{
				ChatManager obj2 = chatManager;
				obj2.chatHistoryIndex++;
			}
			else
			{
				chatManager.chatHistoryIndex = 0;
			}
			chatManager.chatMessage = chatManager.chatHistory[chatManager.chatHistoryIndex];
			((TMP_Text)chatManager.chatText).text = chatManager.chatMessage;
			((SemiUI)ChatUI.instance).SemiUITextFlashColor(Color.cyan, 0.2f);
			((SemiUI)ChatUI.instance).SemiUISpringShakeY(2f, 5f, 0.2f);
			MenuManager.instance.MenuEffectClick((MenuClickEffectType)4, (MenuPage)null, 1f, 0.2f, true);
		}

		private void OnFunctionKeyPressed(KeyboardKeyFunc key)
		{
			switch (key.ButtonFunction)
			{
			case KeyboardKeyFunc.Function.Backspace:
				if (chatManager.chatMessage.Length != 0)
				{
					string chatMessage = chatManager.chatMessage;
					chatMessage = chatMessage.Remove(Mathf.Max(chatMessage.Length - 1, 0));
					chatManager.chatMessage = chatMessage;
					((TMP_Text)chatManager.chatText).text = chatMessage;
					chatManager.CharRemoveEffect();
				}
				break;
			case KeyboardKeyFunc.Function.Enter:
				chatManager.StateSet((ChatState)((!(chatManager.chatMessage == "")) ? 3 : 0));
				break;
			case KeyboardKeyFunc.Function.Space:
				AppendText(" ");
				break;
			case KeyboardKeyFunc.Function.Previous:
				ChatHistoryCycle(previous: true);
				break;
			case KeyboardKeyFunc.Function.Next:
				ChatHistoryCycle(previous: false);
				break;
			}
		}
	}
	public class Crosshair : MonoBehaviour
	{
		public static Crosshair instance;

		public const int LayerMask = 9504257;

		private Transform camera;

		private Transform sprite;

		private void Awake()
		{
			instance = this;
			camera = ((Component)Camera.main).transform;
			sprite = ((Component)((Component)this).GetComponentInChildren<Aim>(true)).transform;
		}

		private void OnDestroy()
		{
			instance = null;
		}

		private void Update()
		{
			//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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_00fe: 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_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: 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)
			//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_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			VRSession vRSession = VRSession.Instance;
			if (vRSession != null)
			{
				RaycastHit val = default(RaycastHit);
				if (!Physics.Raycast(new Ray(vRSession.Player.MainHand.position, vRSession.Player.MainHand.forward), ref val, 10f, 9504257))
				{
					((Component)this).transform.position = Vector3.down * 3000f;
					return;
				}
				if (Object.op_Implicit((Object)(object)PhysGrabber.instance.grabbedObject))
				{
					sprite.position = Vector3.down * 3000f;
					return;
				}
				if (((Component)((RaycastHit)(ref val)).collider).CompareTag("Phys Grab Object") && Object.op_Implicit((Object)(object)((Component)((RaycastHit)(ref val)).collider).GetComponentInParent<EnemyRigidbody>()))
				{
					((Component)this).transform.SetPositionAndRotation(((RaycastHit)(ref val)).point, Quaternion.LookRotation(((RaycastHit)(ref val)).point - camera.position) * Quaternion.Euler(0f, 90f, 90f));
					return;
				}
				float num = Mathf.Abs(Mathf.Max(0f, Vector3.Dot(((RaycastHit)(ref val)).normal, Vector3.up) - 0.5f)) / 0.5f;
				Vector3 val2 = Vector3.ProjectOnPlane(camera.position - ((RaycastHit)(ref val)).point, ((RaycastHit)(ref val)).normal);
				Vector3 normalized = ((Vector3)(ref val2)).normalized;
				Quaternion val3 = Quaternion.LookRotation(Quaternion.AngleAxis(90f, ((RaycastHit)(ref val)).normal) * normalized, ((RaycastHit)(ref val)).normal);
				Quaternion val4 = Quaternion.Lerp(Quaternion.Euler(0f, ((Quaternion)(ref val3)).eulerAngles.y, ((Quaternion)(ref val3)).eulerAngles.z), val3, num);
				((Component)this).transform.SetPositionAndRotation(((RaycastHit)(ref val)).point, val4);
				sprite.localScale = Vector3.Lerp(Vector3.one * 0.3f, Vector3.one, ((RaycastHit)(ref val)).distance * 0.33f);
				sprite.localPosition = Vector3.zero;
			}
		}
	}
	[ExecuteInEditMode]
	[RequireComponent(typeof(TextMeshProUGUI))]
	public class CurvedTMP : MonoBehaviour
	{
		private TextMeshProUGUI textComponent;

		[SerializeField]
		private float radius = 10f;

		private void Awake()
		{
			textComponent = ((Component)this).GetComponent<TextMeshProUGUI>();
		}

		private void OnEnable()
		{
			((TMP_Text)textComponent).OnPreRenderText += UpdateTextCurve;
			OnCurvePropertyChanged();
		}

		private void OnDisable()
		{
			((TMP_Text)textComponent).OnPreRenderText -= UpdateTextCurve;
		}

		private void OnCurvePropertyChanged()
		{
			UpdateTextCurve(((TMP_Text)textComponent).textInfo);
			((TMP_Text)textComponent).ForceMeshUpdate(false, false);
		}

		private void UpdateTextCurve(TMP_TextInfo textInfo)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: 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_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: 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_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < Mathf.Min(textInfo.characterCount, textInfo.characterInfo.Length); i++)
			{
				if (textInfo.characterInfo[i].isVisible)
				{
					int vertexIndex = textInfo.characterInfo[i].vertexIndex;
					int materialReferenceIndex = textInfo.characterInfo[i].materialReferenceIndex;
					Vector3[] vertices = textInfo.meshInfo[materialReferenceIndex].vertices;
					Vector3 val = Vector2.op_Implicit(new Vector2((vertices[vertexIndex].x + vertices[vertexIndex + 2].x) / 2f, textInfo.characterInfo[i].baseLine));
					ref Vector3 reference = ref vertices[vertexIndex];
					reference += -val;
					ref Vector3 reference2 = ref vertices[vertexIndex + 1];
					reference2 += -val;
					ref Vector3 reference3 = ref vertices[vertexIndex + 2];
					reference3 += -val;
					ref Vector3 reference4 = ref vertices[vertexIndex + 3];
					reference4 += -val;
					Matrix4x4 val2 = ComputeTransformationMatrix(val, textInfo, i);
					vertices[vertexIndex] = ((Matrix4x4)(ref val2)).MultiplyPoint3x4(vertices[vertexIndex]);
					vertices[vertexIndex + 1] = ((Matrix4x4)(ref val2)).MultiplyPoint3x4(vertices[vertexIndex + 1]);
					vertices[vertexIndex + 2] = ((Matrix4x4)(ref val2)).MultiplyPoint3x4(vertices[vertexIndex + 2]);
					vertices[vertexIndex + 3] = ((Matrix4x4)(ref val2)).MultiplyPoint3x4(vertices[vertexIndex + 3]);
				}
			}
		}

		private Matrix4x4 ComputeTransformationMatrix(Vector3 charMidBaselinePos, TMP_TextInfo textInfo, int charIdx)
		{
			//IL_0037: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			float num = radius + textInfo.lineInfo[textInfo.characterInfo[charIdx].lineNumber].baseline;
			float num2 = 2f * num * MathF.PI;
			float num3 = ((charMidBaselinePos.x / num2 - 0.5f) * 360f + 90f) * (MathF.PI / 180f);
			float num4 = Mathf.Cos(num3);
			float num5 = Mathf.Sin(num3);
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(num4 * num, (0f - num5) * num);
			float num6 = (0f - Mathf.Atan2(num5, num4)) * 57.29578f - 90f;
			return Matrix4x4.TRS(new Vector3(val.x, val.y, 0f), Quaternion.AngleAxis(num6, Vector3.forward), Vector3.one);
		}
	}
	public class FocusSphere : MonoBehaviour
	{
		private static readonly int FadeStart = Shader.PropertyToID("_FadeStart");

		private static readonly int FadeEnd = Shader.PropertyToID("_FadeEnd");

		[SerializeField]
		protected Renderer renderer;

		[SerializeField]
		protected AnimationCurve animIn;

		[SerializeField]
		protected AnimationCurve animOut;

		private Transform camera;

		private Transform? lookAtTarget;

		private float lookAtTimer;

		private float lookAtSpeed;

		private float lookAtStrength;

		private float strengthLerp;

		private void Awake()
		{
			renderer.material.SetFloat(FadeStart, 0f);
			renderer.material.SetFloat(FadeEnd, 0f);
			camera = ((Component)Camera.main).transform;
		}

		private void Update()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.localPosition = camera.localPosition;
			bool num = (Object)(object)lookAtTarget != (Object)null;
			bool flag = num && lookAtTimer > 0f;
			strengthLerp = Mathf.Clamp01(strengthLerp + (flag ? lookAtSpeed : (0f - lookAtSpeed)) * Time.deltaTime);
			if (lookAtTimer > 0f)
			{
				lookAtTimer = Mathf.Max(0f, lookAtTimer - Time.deltaTime);
				renderer.material.SetFloat(FadeStart, animIn.Evaluate(strengthLerp) * lookAtStrength * 0.92f);
				renderer.material.SetFloat(FadeEnd, animIn.Evaluate(strengthLerp) * lookAtStrength);
			}
			else if (strengthLerp > 0f)
			{
				renderer.material.SetFloat(FadeStart, animOut.Evaluate(strengthLerp) * lookAtStrength * 0.92f);
				renderer.material.SetFloat(FadeEnd, animOut.Evaluate(strengthLerp) * lookAtStrength);
			}
			if (num && strengthLerp > 0f)
			{
				((Component)this).transform.LookAt(lookAtTarget);
			}
		}

		public void SetLookAtTarget(Transform target, float time, float speed, float strength)
		{
			strength = Mathf.Clamp01(strength);
			lookAtTarget = target;
			lookAtTimer = time;
			lookAtSpeed = speed;
			lookAtStrength = strength;
		}
	}
	public class GameHud : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <Start>d__11 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public GameHud <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Start>d__11(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0071: 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)
				int num = <>1__state;
				GameHud gameHud = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					gameHud.camera = ((Component)CameraOverlay.instance.overlayCamera).transform;
					DisableEventSystem();
					gameHud.SetupOverlayCanvas();
					gameHud.SetupSmoothedCanvas();
					gameHud.SetupPauseMenu();
					gameHud.SetupInfoHUD();
					((Component)HUDCanvas.instance).transform.position = Vector3.down * 10000f;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private Transform smoothCanvasContainer;

		private Transform camera;

		private PauseUI pause;

		public Canvas OverlayCanvas { get; private set; }

		public Canvas SmoothedCanvas { get; private set; }

		[IteratorStateMachine(typeof(<Start>d__11))]
		private IEnumerator Start()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Start>d__11(0)
			{
				<>4__this = this
			};
		}

		private void LateUpdate()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: 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_00af: 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_00d5: 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_00e0: 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)
			if (Object.op_Implicit((Object)(object)camera))
			{
				Vector3 val = ((Object.op_Implicit((Object)(object)SpectateCamera.instance) && SpectateCamera.instance.CheckState((State)0)) ? ((Component)SpectateCamera.instance).transform.up : Vector3.up);
				Vector3 val2 = camera.position + Vector3.down * 0.15f + camera.forward * Plugin.Config.SmoothCanvasDistance.Value;
				Quaternion val3 = Quaternion.LookRotation(camera.forward, val);
				((Component)SmoothedCanvas).transform.position = Vector3.Slerp(((Component)SmoothedCanvas).transform.position, val2, 0.1f);
				((Component)SmoothedCanvas).transform.rotation = Quaternion.Slerp(((Component)SmoothedCanvas).transform.rotation, val3, 0.1f);
			}
		}

		public void PauseGame()
		{
			pause.Show();
		}

		public void ResumeGame(bool instant = false)
		{
			pause.Hide(instant);
		}

		private static void DisableEventSystem()
		{
			GameObject obj = GameObject.Find("EventSystem");
			InputSystemUIInputModule val = ((obj != null) ? obj.GetComponent<InputSystemUIInputModule>() : null);
			if ((Object)(object)val != (Object)null)
			{
				((Behaviour)val).enabled = false;
			}
		}

		private void SetupOverlayCanvas()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			OverlayCanvas = GameObject.Find("VR Overlay Canvas").GetComponent<Canvas>();
			OverlayCanvas.worldCamera = CameraOverlay.instance.overlayCamera;
			OverlayCanvas.renderMode = (RenderMode)1;
			((Component)WorldSpaceUIParent.instance).transform.localScale = Vector3.one * 0.005f;
			TumbleUI instance = TumbleUI.instance;
			RectTransform component = ((Component)instance).GetComponent<RectTransform>();
			((Component)component).transform.parent = ((Component)OverlayCanvas).transform;
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.anchoredPosition = Vector2.zero;
			component.sizeDelta = Vector2.zero;
			((Component)component).transform.localPosition = Vector3.down * 130f;
			((Component)component).transform.localRotation = Quaternion.identity;
			foreach (Transform item in (Transform)component)
			{
				Object.Destroy((Object)(object)((Component)item).gameObject);
			}
			Transform transform = Object.Instantiate<GameObject>(AssetCollection.VRTumble, (Transform)(object)component).transform;
			instance.parts1[0] = ((Component)transform.Find("Top 1")).gameObject;
			instance.parts1[1] = ((Component)transform.Find("Bottom 1")).gameObject;
			instance.parts1[2] = ((Component)transform.Find("Left 1")).gameObject;
			instance.parts1[3] = ((Component)transform.Find("Right 1")).gameObject;
			instance.parts2[0] = ((Component)transform.Find("Top 2")).gameObject;
			instance.parts2[1] = ((Component)transform.Find("Bottom 2")).gameObject;
			instance.parts2[2] = ((Component)transform.Find("Left 2")).gameObject;
			instance.parts2[3] = ((Component)transform.Find("Right 2")).gameObject;
			instance.images1 = instance.parts1.Select((GameObject part) => part.GetComponent<Image>()).ToArray();
			instance.images2 = instance.parts2.Select((GameObject part) => part.GetComponent<Image>()).ToArray();
		}

		private void SetupSmoothedCanvas()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("VR Smoothed Canvas - Container")
			{
				layer = 5
			};
			val.transform.parent = camera.parent.parent.parent;
			smoothCanvasContainer = val.transform;
			GameObject val2 = new GameObject("VR Smoothed Canvas")
			{
				layer = 5
			};
			val2.transform.parent = smoothCanvasContainer;
			val2.transform.localScale = Vector3.one * 0.003f;
			val2.transform.localPosition = Vector3.zero;
			val2.transform.localEulerAngles = Vector3.zero;
			SmoothedCanvas = val2.AddComponent<Canvas>();
			SmoothedCanvas.renderMode = (RenderMode)2;
			((Component)SmoothedCanvas).gameObject.AddComponent<RectMask2D>();
			RectTransform component = ((Component)SmoothedCanvas).GetComponent<RectTransform>();
			component.sizeDelta = new Vector2(712f, 400f);
			Transform val3 = ((Component)HUDCanvas.instance).transform.Find("HUD/Game Hud");
			Transform val4 = ((Component)HUDCanvas.instance).transform.Find("HUD/Chat Local");
			GameObject obj = GameObject.Find("UI/UI/Canvas/DebugConsole");
			Transform obj2 = ((obj != null) ? obj.transform : null);
			val3.SetParent((Transform)(object)component, false);
			val4.SetParent((Transform)(object)component, false);
			if (obj2 != null)
			{
				obj2.SetParent((Transform)(object)component, false);
			}
		}

		private void SetupPauseMenu()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_003a: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: 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_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: 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_019f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("VR Pause Menu / Chat");
			val.transform.parent = ((Component)camera).transform.parent.parent;
			val.transform.localPosition = Vector3.down * 3000f;
			val.transform.localRotation = Quaternion.identity;
			val.transform.localScale = Vector3.one * 0.01f;
			val.layer = 5;
			Canvas val2 = val.AddComponent<Canvas>();
			Transform transform = ((Component)MenuHolder.instance).transform;
			RectTransform component = ((Component)transform).GetComponent<RectTransform>();
			((Component)val2).gameObject.AddComponent<TrackedDeviceGraphicRaycaster>();
			val2.renderMode = (RenderMode)2;
			val2.sortingOrder = 5;
			transform.SetParent(((Component)val2).transform, false);
			transform.localPosition = Vector3.zero;
			transform.localRotation = Quaternion.identity;
			transform.localScale = Vector3.one;
			((Component)transform).gameObject.AddComponent<RectMask2D>();
			Vector2 val3 = -(component.sizeDelta * 0.5f) + new Vector2(50f, 0f);
			pause = ((Component)val2).gameObject.AddComponent<PauseUI>();
			pause.positionOffset = new Vector3(val3.x * 0.01f, val3.y * 0.01f, 0f);
			GameObject val4 = new GameObject("Chat Holder");
			val4.transform.parent = ((Component)val2).transform;
			RectTransform val5 = val4.AddComponent<RectTransform>();
			val5.sizeDelta = new Vector2(720f, 450f);
			val5.pivot = Vector2.zero;
			((Transform)val5).localPosition = Vector3.zero;
			((Transform)val5).localRotation = Quaternion.identity;
			((Transform)val5).localScale = Vector3.one;
			((Component)val5).gameObject.AddComponent<RectMask2D>();
			Transform val6 = ((Component)HUDCanvas.instance).transform.Find("HUD/Chat");
			if (SemiFunc.IsMultiplayer())
			{
				val6.SetParent((Transform)(object)val5, false);
			}
			else
			{
				((Component)val6).gameObject.SetActive(false);
			}
		}

		private void SetupInfoHUD()
		{
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			SemiUI component = ((Component)GoalUI.instance).GetComponent<SemiUI>();
			SemiUI component2 = ((Component)HaulUI.instance).GetComponent<SemiUI>();
			SemiUI component3 = ((Component)HealthUI.instance).GetComponent<SemiUI>();
			SemiUI component4 = ((Component)EnergyUI.instance).GetComponent<SemiUI>();
			SemiUI component5 = ((Component)StatsUI.instance).GetComponent<SemiUI>();
			SemiUI component6 = ((Component)LevelUI.instance).GetComponent<SemiUI>();
			((Component)component).transform.SetParent((Transform)(object)VRSession.Instance.Player.Rig.infoHud, false);
			((Component)component2).transform.SetParent((Transform)(object)VRSession.Instance.Player.Rig.infoHud, false);
			((Component)component3).transform.SetParent((Transform)(object)VRSession.Instance.Player.Rig.infoHud, false);
			((Component)component4).transform.SetParent((Transform)(object)VRSession.Instance.Player.Rig.infoHud, false);
			((Component)component5).transform.SetParent((Transform)(object)VRSession.Instance.Player.Rig.infoHud, false);
			((Component)component6).transform.SetParent((Transform)(object)VRSession.Instance.Player.Rig.infoHud, false);
			component.DisableScanlines();
			component2.DisableScanlines();
			component3.DisableScanlines();
			component4.DisableScanlines();
			component5.DisableScanlines();
			component6.DisableScanlines();
			component.SetUIAnchoredPosition(new Vector2(0f, -30f));
			component2.SetUIAnchoredPosition(Vector2.zero);
			component3.SetUIAnchoredPosition(new Vector2(30f, 0f));
			component4.SetUIAnchoredPosition(new Vector2(30f, -30f));
			component5.SetUIAnchoredPosition(new Vector2(50f, 50f));
			component6.SetUIAnchoredPosition(new Vector2(50f, 50f));
		}
	}
	public class LoadingUI : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <Start>d__6 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LoadingUI <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Start>d__6(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				LoadingUI loadingUI = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					loadingUI.RestorePosition();
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					loadingUI.RestorePosition();
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static LoadingUI instance;

		private static Vector3 lastLocalPosition;

		private static float lastLocalRotation;

		private Transform camera;

		private void Awake()
		{
			instance = this;
			camera = ((Component)Camera.main).transform;
			RestorePosition();
		}

		private void OnDestroy()
		{
			instance = null;
		}

		[IteratorStateMachine(typeof(<Start>d__6))]
		private IEnumerator Start()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Start>d__6(0)
			{
				<>4__this = this
			};
		}

		private void OnDisable()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			lastLocalPosition = ((Component)this).transform.localPosition;
			lastLocalRotation = ((Component)this).transform.localEulerAngles.y;
		}

		public void ResetPosition()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//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_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = camera.localRotation * Vector3.forward;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			normalized.y = 0f;
			((Vector3)(ref normalized)).Normalize();
			Vector3 val2 = ((Component)camera).transform.localPosition + normalized * 5f + Vector3.up * 0.15f;
			val = new Vector3(camera.localPosition.x, val2.y, camera.localPosition.z) - val2;
			Vector3 val3 = -((Vector3)(ref val)).normalized;
			((Component)this).transform.localPosition = val2;
			((Component)this).transform.localRotation = Quaternion.LookRotation(val3);
		}

		private void RestorePosition()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.localPosition = lastLocalPosition;
			((Component)this).transform.localEulerAngles = lastLocalRotation * Vector3.up;
		}
	}
	public class MainMenu : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <LobbyLinkCopy>d__9 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <LobbyLinkCopy>d__9(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if ((Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305)) && Input.GetKeyDown((KeyCode)99))
					{
						Lobby currentLobby = SteamManager.instance.currentLobby;
						string text2 = (GUIUtility.systemCopyBuffer = $"steam://joinlobby/3241660/{((Lobby)(ref currentLobby)).Id}/{((Lobby)(ref currentLobby)).Owner.Id}");
						Logger.LogInfo("Copied lobby link: " + text2);
					}
				}
				else
				{
					<>1__state = -1;
				}
				<>2__current = null;
				<>1__state = 1;
				return true;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <Start>d__4 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MainMenu <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Start>d__4(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				MainMenu mainMenu = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					DisableEventSystem();
					mainMenu.SetupMainCamera();
					mainMenu.SetupMainCanvas();
					mainMenu.SetupControllers();
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private Camera mainCamera;

		private Canvas mainCanvas;

		private void Awake()
		{
			Actions.Instance["ResetHeight"].performed += OnResetHeight;
			if ((Object)(object)RunManager.instance.levelCurrent == (Object)(object)RunManager.instance.levelLobbyMenu)
			{
				((MonoBehaviour)this).StartCoroutine(LobbyLinkCopy());
			}
		}

		private void OnDestroy()
		{
			Actions.Instance["ResetHeight"].performed -= OnResetHeight;
		}

		[IteratorStateMachine(typeof(<Start>d__4))]
		private IEnumerator Start()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Start>d__4(0)
			{
				<>4__this = this
			};
		}

		private static void DisableEventSystem()
		{
			GameObject obj = GameObject.Find("EventSystem");
			InputSystemUIInputModule val = ((obj != null) ? obj.GetComponent<InputSystemUIInputModule>() : null);
			if ((Object)(object)val != (Object)null)
			{
				((Behaviour)val).enabled = false;
			}
		}

		private void SetupMainCamera()
		{
			mainCamera = CameraUtils.Instance.MainCamera;
			Camera component = ((Component)((Component)mainCamera).transform.Find("Camera Top")).GetComponent<Camera>();
			component.depth = 1f;
			component.targetTexture = null;
		}

		private void SetupMainCanvas()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			mainCanvas = ((Component)HUDCanvas.instance).GetComponent<Canvas>();
			mainCanvas.renderMode = (RenderMode)2;
			((Component)mainCanvas).transform.position = new Vector3(-45f, -0.75f, 6f);
			((Component)mainCanvas).transform.eulerAngles = new Vector3(0f, 50f, 0f);
			((Component)mainCanvas).transform.localScale = Vector3.one * 0.03f;
			((Component)((Component)mainCanvas).transform.Find("HUD")).gameObject.AddComponent<RectMask2D>();
			Object.Destroy((Object)(object)((Component)mainCanvas).GetComponent<GraphicRaycaster>());
			((Component)mainCanvas).gameObject.AddComponent<TrackedDeviceGraphicRaycaster>();
			((Component)((Component)mainCanvas).transform.Find("HUD/Game Hud")).gameObject.SetActive(false);
			((Component)((Component)mainCanvas).transform.Find("HUD/Chat Local")).gameObject.SetActive(false);
			if ((Object)(object)RunManager.instance.levelCurrent == (Object)(object)RunManager.instance.levelLobbyMenu)
			{
				((Transform)((Component)((Component)mainCanvas).transform.Find("HUD/Chat")).GetComponent<RectTransform>()).SetParent(((Component)mainCanvas).transform.Find("HUD"), false);
			}
			else
			{
				((Component)((Component)mainCanvas).transform.Find("HUD/Chat")).gameObject.SetActive(false);
			}
			MenuSelectionBoxTop val = Object.FindObjectOfType<MenuSelectionBoxTop>(true);
			((Component)val).transform.parent.parent = ((Component)val).transform.parent.parent.parent;
		}

		private void SetupControllers()
		{
			((Component)((Component)mainCamera).transform.parent).gameObject.AddComponent<XRRayInteractorManager>();
		}

		[IteratorStateMachine(typeof(<LobbyLinkCopy>d__9))]
		private static IEnumerator LobbyLinkCopy()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LobbyLinkCopy>d__9(0);
		}

		private static void OnResetHeight(CallbackContext obj)
		{
			VRCameraAim.instance.SetPlayerAim(0f, forceInitial: true);
		}
	}
	public class PasswordUI : MonoBehaviour
	{
		private MenuPagePassword passwordPage;

		private NonNativeKeyboard keyboard;

		private void Awake()
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			passwordPage = ((Component)this).GetComponent<MenuPagePassword>();
			LoadingUI instance = LoadingUI.instance;
			((Component)instance).gameObject.AddComponent<TrackedDeviceGraphicRaycaster>();
			((Component)instance).gameObject.AddComponent<RectMask2D>();
			((Component)passwordPage).transform.SetParent(((Component)instance).transform);
			((Component)passwordPage).transform.localPosition = Vector3.zero;
			((Component)passwordPage).transform.localRotation = Quaternion.identity;
			((Component)passwordPage).transform.localScale = Vector3.one;
			((Component)passwordPage).GetComponent<RectTransform>().pivot = Vector2.one * 0.5f;
			((Component)Object.FindObjectOfType<MenuSelectionBoxTop>()).transform.parent.SetParent(((Component)instance).transform);
			keyboard = Object.Instantiate<GameObject>(AssetCollection.Keyboard).GetComponent<NonNativeKeyboard>();
			((Component)keyboard).transform.position = ((Component)instance).transform.position + Vector3.down * 1.5f;
			((Component)keyboard).transform.rotation = ((Component)instance).transform.rotation * Quaternion.Euler(15f, 0f, 0f);
			keyboard.PresentKeyboard();
			keyboard.OnKeyboardValueKeyPressed += OnKeyboardKeyPressed;
			keyboard.OnKeyboardFunctionKeyPressed += OnKeyboardFunctionKeyPressed;
			if (!Object.op_Implicit((Object)(object)XRRayInteractorManager.Instance))
			{
				new GameObject("Controllers").AddComponent<XRRayInteractorManager>();
			}
			XRRayInteractorManager.Instance.SetLineSortingOrder(15);
		}

		private void OnDestroy()
		{
			keyboard.OnKeyboardValueKeyPressed -= OnKeyboardKeyPressed;
			keyboard.OnKeyboardFunctionKeyPressed -= OnKeyboardFunctionKeyPressed;
		}

		public void OnConfirm()
		{
			keyboard.Close();
			XRRayInteractorManager.Instance?.SetLineSortingOrder(0);
		}

		private void OnKeyboardKeyPressed(KeyboardValueKey key)
		{
			MenuPagePassword obj = passwordPage;
			obj.password += (keyboard.IsShifted ? key.ShiftValue : key.Value);
		}

		private void OnKeyboardFunctionKeyPressed(KeyboardKeyFunc key)
		{
			switch (key.ButtonFunction)
			{
			case KeyboardKeyFunc.Function.Enter:
				passwordPage.ConfirmButton();
				break;
			case KeyboardKeyFunc.Function.Backspace:
				passwordPage.password = passwordPage.password.Remove(Mathf.Max(passwordPage.password.Length - 1, 0));
				break;
			}
		}
	}
	public class PauseUI : MonoBehaviour
	{
		public static PauseUI? instance;

		public Vector3 positionOffset;

		private Vector3 targetPos;

		private Quaternion targetRot;

		private Transform camera;

		private XRRayInteractorManager interactor;

		private bool isOpen;

		private float darkness;

		private void Awake()
		{
			//IL_0069: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			instance = this;
			camera = ((Component)Camera.main).transform;
			interactor = ((Component)((Component)camera).transform.parent).gameObject.AddComponent<XRRayInteractorManager>();
			interactor.SetVisible(visible: false);
			MenuSelectionBoxTop obj = Object.FindObjectOfType<MenuSelectionBoxTop>();
			((Component)obj).transform.parent.SetParent(((Component)this).transform, false);
			((Component)obj).transform.parent.localPosition = Vector3.zero;
			((Component)obj).transform.parent.localRotation = Quaternion.identity;
			((Component)obj).transform.parent.localScale = Vector3.one;
		}

		private void OnEnable()
		{
			Actions.Instance["ResetHeight"].performed += OnResetHeight;
		}

		private void OnDisable()
		{
			Actions.Instance["ResetHeight"].performed -= OnResetHeight;
		}

		private void OnDestroy()
		{
			instance = null;
		}

		private void Update()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.localPosition = Vector3.Lerp(((Component)this).transform.localPosition, targetPos, 8f * Time.deltaTime);
			((Component)this).transform.localRotation = Quaternion.Slerp(((Component)this).transform.localRotation, targetRot, 8f * Time.deltaTime);
		}

		private void LateUpdate()
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			darkness = Mathf.Lerp(darkness, isOpen ? 0.75f : 0f, 6f * Time.deltaTime);
			if (darkness < 0.01f)
			{
				darkness = 0f;
			}
			if (darkness > 0f)
			{
				((Graphic)FadeOverlay.Instance.Image).color = new Color(0f, 0f, 0f, darkness);
				interactor.SetLineSortingOrder(6);
			}
			else
			{
				interactor.SetLineSortingOrder(4);
			}
		}

		public void Show()
		{
			if (!isOpen)
			{
				isOpen = true;
				ResetPosition(instant: true);
				interactor.SetVisible(visible: true);
			}
		}

		public void Hide(bool instant)
		{
			isOpen = false;
			interactor.SetVisible(visible: false);
			if (instant)
			{
				MenuManager.instance.PageCloseAll();
				darkness = 0f;
			}
		}

		public void ResetPosition(bool instant = false)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = camera.localRotation * Vector3.forward;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			normalized.y = 0f;
			((Vector3)(ref normalized)).Normalize();
			Vector3 val2 = ((Component)camera).transform.localPosition + normalized * 5f + Vector3.up * 0.15f;
			Vector3 val3 = default(Vector3);
			((Vector3)(ref val3))..ctor(camera.localPosition.x, val2.y, camera.localPosition.z);
			val = val3 - val2;
			targetRot = Quaternion.LookRotation(-((Vector3)(ref val)).normalized);
			targetPos = val2 + targetRot * positionOffset;
			if (instant)
			{
				((Component)this).transform.localPosition = targetPos;
				((Component)this).transform.localRotation = targetRot;
			}
		}

		private void OnResetHeight(CallbackContext ctx)
		{
			if (((CallbackContext)(ref ctx)).performed && isOpen)
			{
				ResetPosition();
			}
		}
	}
	public class ValuableDiscoverGraphic : MonoBehaviour
	{
		private static readonly int BaseColor = Shader.PropertyToID("_BaseColor");

		private static readonly int EdgeColor = Shader.PropertyToID("_EdgeColor");

		public Renderer renderer;

		private ValuableDiscoverGraphic baseGraphic;

		internal PhysGrabObject target;

		private State state;

		private bool discovered;

		private float waitTimer;

		private float animLerp;

		private Vector3 targetCenter;

		private Vector3 targetSize;

		private void Awake()
		{
			baseGraphic = ValuableDiscover.instance.graphicPrefab.GetComponent<ValuableDiscoverGraphic>();
		}

		private void Start()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			((Component)this).transform.localScale = Vector3.zero;
			State val = state;
			float num = (((int)val == 1) ? 0.5f : (((int)val != 2) ? 1f : 3f));
			waitTimer = num;
		}

		private void Update()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Invalid comparison between Unknown and I4
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)target))
			{
				Bounds val = default(Bounds);
				((Bounds)(ref val))..ctor(target.centerPoint, Vector3.zero);
				MeshRenderer[] componentsInChildren = ((Component)target).GetComponentsInChildren<MeshRenderer>();
				foreach (MeshRenderer val2 in componentsInChildren)
				{
					((Bounds)(ref val)).Encapsulate(((Renderer)val2).bounds);
				}
				((Bounds)(ref val)).Expand(0.05f);
				targetCenter = ((Bounds)(ref val)).center;
				targetSize = ((Bounds)(ref val)).size;
				if (VREyeTracking.LookingAt(((Bounds)(ref val)).center, 0.5f, 0.5f) && !discovered)
				{
					if ((int)state == 1)
					{
						baseGraphic.sound.Play(target.centerPoint, 0.3f, 1f, 1f, 1f);
					}
					else
					{
						baseGraphic.sound.Play(target.centerPoint, 1f, 1f, 1f, 1f);
					}
					renderer.enabled = true;
					discovered = true;
				}
			}
			else
			{
				waitTimer = 0f;
			}
			((Component)this).transform.position = targetCenter;
			if (waitTimer > 0f)
			{
				animLerp = Mathf.Clamp01(animLerp + baseGraphic.introSpeed * Time.deltaTime);
				((Component)this).transform.localScale = Vector3.LerpUnclamped(Vector3.zero, targetSize, baseGraphic.introCurve.Evaluate(animLerp));
				if (!(animLerp < 1f))
				{
					waitTimer -= Time.deltaTime;
					if (waitTimer <= 0f)
					{
						animLerp = 0f;
					}
				}
			}
			else
			{
				animLerp = Mathf.Clamp01(animLerp + baseGraphic.outroSpeed * Time.deltaTime);
				((Component)this).transform.localScale = Vector3.LerpUnclamped(targetSize, Vector3.zero, baseGraphic.outroCurve.Evaluate(animLerp));
				if (animLerp >= 1f)
				{
					Object.Destroy((Object)(object)((Component)this).gameObject);
				}
			}
		}

		public void ReminderSetup()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			state = (State)1;
			Color colorReminderMiddle = baseGraphic.ColorReminderMiddle;
			Color colorReminderCorner = baseGraphic.ColorReminderCorner;
			renderer.material.SetColor(BaseColor, colorReminderMiddle);
			renderer.material.SetColor(EdgeColor, colorReminderCorner);
		}

		public void BadSetup()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			state = (State)2;
			Color colorBadMiddle = baseGraphic.ColorBadMiddle;
			Color colorBadCorner = baseGraphic.ColorBadCorner;
			renderer.material.SetColor(BaseColor, colorBadMiddle);
			renderer.material.SetColor(EdgeColor, colorBadCorner);
		}

		public void CustomSetup(State newState, Color baseColor, Color edgeColor)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			state = newState;
			renderer.material.SetColor(BaseColor, baseColor);
			renderer.material.SetColor(EdgeColor, edgeColor);
		}
	}
	public class XRRayInteractorManager : MonoBehaviour
	{
		private enum ActiveController
		{
			Left,
			Right
		}

		private XRRayInteractor leftInteractor;

		private XRRayInteractor rightInteractor;

		private ActionBasedController leftActions;

		private ActionBasedController rightActions;

		private LineRenderer leftRenderer;

		private LineRenderer rightRenderer;

		private ActiveController activeController;

		public static XRRayInteractorManager? Instance { get; private set; }

		private void Awake()
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			(ActionBasedController, XRRayInteractor, LineRenderer) tuple = CreateInteractorController("Left");
			leftActions = tuple.Item1;
			leftInteractor = tuple.Item2;
			leftRenderer = tuple.Item3;
			tuple = CreateInteractorController("Right");
			rightActions = tuple.Item1;
			rightInteractor = tuple.Item2;
			rightRenderer = tuple.Item3;
			InputActionProperty uiPressAction = leftActions.uiPressAction;
			((InputActionProperty)(ref uiPressAction)).action.performed += LeftControllerPressed;
			uiPressAction = rightActions.uiPressAction;
			((InputActionProperty)(ref uiPressAction)).action.performed += RightControllerPressed;
			UpdateActiveController(ActiveController.Right);
		}

		private void OnDestroy()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			Instance = null;
			InputActionProperty uiPressAction = leftActions.uiPressAction;
			((InputActionProperty)(ref uiPressAction)).action.performed -= LeftControllerPressed;
			uiPressAction = rightActions.uiPressAction;
			((InputActionProperty)(ref uiPressAction)).action.performed -= RightControllerPressed;
		}

		public void SetVisible(bool visible)
		{
			((Behaviour)((Component)leftInteractor).GetComponent<XRInteractorLineVisual>()).enabled = visible;
			((Behaviour)((Component)rightInteractor).GetComponent<XRInteractorLineVisual>()).enabled = visible;
		}

		public void SetLineSortingOrder(int sortingOrder)
		{
			((Renderer)leftRenderer).sortingOrder = sortingOrder;
			((Renderer)rightRenderer).sortingOrder = sortingOrder;
		}

		private void LeftControllerPressed(CallbackContext obj)
		{
			UpdateActiveController(ActiveController.Left);
		}

		private void RightControllerPressed(CallbackContext obj)
		{
			UpdateActiveController(ActiveController.Right);
		}

		public Vector2 GetUIHitPosition(RectTransform? rect)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			RaycastResult val = default(RaycastResult);
			if (!GetActiveInteractor().Item1.TryGetCurrentUIRaycastResult(ref val))
			{
				return Vector2.one * -1000f;
			}
			Vector3 val2 = ((rect == null) ? ((Component)((RaycastResult)(ref val)).gameObject.GetComponentInParent<Canvas>()).transform : ((Component)((Component)rect).GetComponentInParent<Canvas>()).transform).InverseTransformPoint(val.worldPosition);
			return new Vector2(val2.x, val2.y);
		}

		public RectTransform GetUIHitRectTransform()
		{
			RaycastResult val = default(RaycastResult);
			if (GetActiveInteractor().Item1.TryGetCurrentUIRaycastResult(ref val))
			{
				return ((RaycastResult)(ref val)).gameObject.GetComponent<RectTransform>();
			}
			return ((Component)HUDCanvas.instance).GetComponent<RectTransform>();
		}

		public bool GetTriggerDown()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			InputActionProperty uiPressAction = GetActiveInteractor().Item2.uiPressAction;
			return ((InputActionProperty)(ref uiPressAction)).action.WasPressedThisFrame();
		}

		public bool GetTriggerButton()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			InputActionProperty uiPressAction = GetActiveInteractor().Item2.uiPressAction;
			return ((InputActionProperty)(ref uiPressAction)).action.IsPressed();
		}

		public float GetUIScrollX()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			InputActionProperty uiScrollAction = GetActiveInteractor().Item2.uiScrollAction;
			return ((InputActionProperty)(ref uiScrollAction)).action.ReadValue<Vector2>().x;
		}

		public float GetUIScrollY()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			InputActionProperty uiScrollAction = GetActiveInteractor().Item2.uiScrollAction;
			return ((InputActionProperty)(ref uiScrollAction)).action.ReadValue<Vector2>().y;
		}

		private void UpdateActiveController(ActiveController newValue)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//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_0088: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Expected O, but got Unknown
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			activeController = newValue;
			XRRayInteractor val = ((newValue == ActiveController.Left) ? rightInteractor : leftInteractor);
			XRRayInteractor obj = ((newValue == ActiveController.Left) ? leftInteractor : rightInteractor);
			XRInteractorLineVisual component = ((Component)val).GetComponent<XRInteractorLineVisual>();
			XRInteractorLineVisual component2 = ((Component)obj).GetComponent<XRInteractorLineVisual>();
			component.lineLength = 1f;
			component2.lineLength = 20f;
			Gradient val2 = new Gradient();
			val2.mode = (GradientMode)0;
			val2.alphaKeys = (GradientAlphaKey[])(object)new GradientAlphaKey[3]
			{
				new GradientAlphaKey(0.05f, 0f),
				new GradientAlphaKey(0.05f, 0.8f),
				new GradientAlphaKey(0f, 1f)
			};
			val2.colorKeys = (GradientColorKey[])(object)new GradientColorKey[2]
			{
				new GradientColorKey(Color.white, 0f),
				new GradientColorKey(Color.white, 1f)
			};
			Gradient invalidColorGradient = (component.validColorGradient = val2);
			component.invalidColorGradient = invalidColorGradient;
			invalidColorGradient = new Gradient();
			invalidColorGradient.mode = (GradientMode)0;
			invalidColorGradient.alphaKeys = (GradientAlphaKey[])(object)new GradientAlphaKey[2]
			{
				new GradientAlphaKey(0.2f, 0f),
				new GradientAlphaKey(0.2f, 1f)
			};
			invalidColorGradient.colorKeys = (GradientColorKey[])(object)new GradientColorKey[2]
			{
				new GradientColorKey(Color.white, 0f),
				new GradientColorKey(Color.white, 1f)
			};
			component2.invalidColorGradient = invalidColorGradient;
			invalidColorGradient = new Gradient();
			invalidColorGradient.mode = (GradientMode)0;
			invalidColorGradient.alphaKeys = (GradientAlphaKey[])(object)new GradientAlphaKey[2]
			{
				new GradientAlphaKey(1f, 0f),
				new GradientAlphaKey(1f, 1f)
			};
			invalidColorGradient.colorKeys = (GradientColorKey[])(object)new GradientColorKey[2]
			{
				new GradientColorKey(Color.white, 0f),
				new GradientColorKey(Color.white, 1f)
			};
			component2.validColorGradient = invalidColorGradient;
		}

		public (XRRayInteractor, ActionBasedController) GetActiveInteractor()
		{
			return activeController switch
			{
				ActiveController.Left => (leftInteractor, leftActions), 
				ActiveController.Right => (rightInteractor, rightActions), 
				_ => throw new ArgumentOutOfRangeException(), 
			};
		}

		private (ActionBasedController, XRRayInteractor, LineRenderer) CreateInteractorController(string hand)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(hand + " Controller");
			val.transform.parent = ((Component)this).transform;
			val.layer = 5;
			ActionBasedController val2 = val.AddComponent<ActionBasedController>();
			XRRayInteractor val3 = val.AddComponent<XRRayInteractor>();
			XRInteractorLineVisual val4 = val.AddComponent<XRInteractorLineVisual>();
			LineRenderer component = val.GetComponent<LineRenderer>();
			val3.raycastMask = LayerMask.op_Implicit(32);
			val4.lineBendRatio = 1f;
			Gradient val5 = new Gradient();
			val5.mode = (GradientMode)0;
			val5.alphaKeys = (GradientAlphaKey[])(object)new GradientAlphaKey[2]
			{
				new GradientAlphaKey(0.1f, 0f),
				new GradientAlphaKey(0.1f, 1f)
			};
			val5.colorKeys = (GradientColorKey[])(object)new GradientColorKey[2]
			{
				new GradientColorKey(Color.white, 0f),
				new GradientColorKey(Color.white, 1f)
			};
			val4.invalidColorGradient = val5;
			((Behaviour)val4).enabled = true;
			val4.lineLength = 20f;
			((Renderer)component).sortingOrder = 4;
			((Renderer)component).material = AssetCollection.DefaultLine;
			AddActionBasedControllerBinds(val2, hand);
			return (val2, val3, component);
		}

		private static void AddActionBasedControllerBinds(ActionBasedController controller, string hand)
		{
			//IL_002b: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: 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_01f9: Unknown result type (might be due to invalid IL or missing references)
			((XRBaseController)controller).enableInputTracking = true;
			controller.positionAction = new InputActionProperty((hand == "Left") ? Actions.Instance.LeftHandPosition : Actions.Instance.RightHandPosition);
			controller.rotationAction = new InputActionProperty((hand == "Left") ? Actions.Instance.LeftHandRotation : Actions.Instance.RightHandRotation);
			controller.trackingStateAction = new InputActionProperty((hand == "Left") ? Actions.Instance.LeftHandTrackingState : Actions.Instance.RightHandTrackingState);
			((XRBaseController)controller).enableInputActions = true;
			controller.selectAction = new InputActionProperty(AssetCollection.DefaultXRActions.FindAction(hand + "/Select", false));
			controller.selectActionValue = new InputActionProperty(AssetCollection.DefaultXRActions.FindAction(hand + "/Select Value", false));
			controller.activateAction = new InputActionProperty(AssetCollection.DefaultXRActions.FindAction(hand + "/Activate", false));
			controller.activateActionValue = new InputActionProperty(AssetCollection.DefaultXRActions.FindAction(hand + "/Activate Value", false));
			controller.uiPressAction = new InputActionProperty(AssetCollection.DefaultXRActions.FindAction(hand + "/UI Press", false));
			controller.uiPressActionValue = new InputActionProperty(AssetCollection.DefaultXRActions.FindAction(hand + "/UI Press Value", false));
			controller.uiScrollAction = new InputActionProperty(AssetCollection.DefaultXRActions.FindAction(hand + "/UI Scroll", false));
			controller.rotateAnchorAction = new InputActionProperty(AssetCollection.DefaultXRActions.FindAction(hand + "/Rotate Anchor", false));
			controller.translateAnchorAction = new InputActionProperty(AssetCollection.DefaultXRActions.FindAction(hand + "/Translate Anchor", false));
			controller.scaleToggleAction = new InputActionProperty(AssetCollection.DefaultXRActions.FindAction(hand + "/Scale Toggle", false));
			controller.scaleDeltaAction = new InputActionProperty(AssetCollection.DefaultXRActions.FindAction(hand + "/Scale Delta", false));
		}
	}
}
namespace RepoXR.UI.Settings
{
	public class FloatMenuSlider : MonoBehaviour
	{
		[Serializable]
		public class CustomOption
		{
			public string customOptionText;

			public UnityEvent onOption;

			public int customValueInt;
		}

		public Transform barSize;

		public Transform barPointer;

		public RectTransform barSizeRectTransform;

		public Transform settingsBar;

		public TextMeshProUGUI segmentText;

		public TextMeshProUGUI segmentMaskText;

		public RectTransform maskRectTransform;

		public float startValue;

		public float endValue;

		public string stringAtStartOfValue;

		public string stringAtEndOfValue;

		public float buttonSegmentJump = 1f;

		public float pointerSegmentJump = 1f;

		public bool displayPercentage;

		public bool isInteger;

		public bool hasBar = true;

		public bool wrapAround;

		public bool hasCustomOptions;

		[Space]
		public UnityEvent onChange;

		public List<CustomOption> customOptions;

		public float currentValue;

		private float prevCurrentValue;

		private bool valueChangedImpulse;

		private bool hovering;

		private MenuSelectableElement menuSelectableElement;

		private RectTransform rectTransform;

		private MenuPage parentPage;

		private Vector3 originalPosition;

		private bool startPositionSetup;

		private int settingSegments;

		private float PercentageValue => Mathf.InverseLerp(startValue, endValue, currentValue);

		private string DisplayValue
		{
			get
			{
				if (!displayPercentage)
				{
					return $"{currentValue}";
				}
				return $"{PercentageValue * 100f}";
			}
		}

		private void Start()
		{
			rectTransform = ((Component)this).GetComponent<RectTransform>();
			parentPage = ((Component)this).GetComponentInParent<MenuPage>();
			menuSelectableElement = ((Component)this).GetComponent<MenuSelectableElement>();
			barSizeRectTransform = ((Component)barSize).GetComponent<RectTransform>();
			settingSegments = Mathf.RoundToInt(endValue - startValue);
			if (hasCustomOptions)
			{
				settingSegments = Mathf.Max(customOptions.Count - 1, 1);
				startValue = 0f;
				endValue = customOptions.Count - 1;
				buttonSegmentJump = 1f;
				if (Mathf.Max(customOptions.Count - 1, 1) != settingSegments)
				{
					Debug.LogWarning((object)"Segment text count is not equal to setting segments count");
				}
				else
				{
					int index = Mathf.RoundToInt(currentValue);
					string text = customOptions[index].customOptionText;
					if (text.Length > 16)
					{
						text = text.Substring(0, 16) + "...";
					}
					((TMP_Text)segmentText).text = text;
				}
			}
			else
			{
				((TMP_Text)segmentText).text = stringAtStartOfValue + DisplayValue + stringAtEndOfValue;
			}
			((TMP_Text)segmentText).enableAutoSizing = false;
			((TMP_Text)segmentMaskText).enableAutoSizing = false;
			if (!hasBar && Object.op_Implicit((Object)(object)segmentText))
			{
				Object.Destroy((Object)(object)((Component)segmentText).gameObject);
			}
			prevCurrentValue = currentValue;
			SetStartPositions();
		}

		public void SetStartPositions()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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)
			if (!startPositionSetup)
			{
				((Transform)barSizeRectTransform).localPosition = new Vector3(((Transform)barSizeRectTransform).localPosition.x + 3f, ((Transform)barSizeRectTransform).localPosition.y, ((Transform)barSizeRectTransform).localPosition.z);
				originalPosition = ((Transform)rectTransform).position;
				originalPosition = new Vector3(originalPosition.x, originalPosition.y - 1.01f, originalPosition.z);
				startPositionSetup = true;
			}
		}

		private void Update()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_008b: 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_00b8: 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_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: 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)
			if (!Mathf.Approximately(prevCurrentValue, currentValue) || valueChangedImpulse)
			{
				valueChangedImpulse = false;
				onChange.Invoke();
				prevCurrentValue = currentValue;
			}
			if (hasBar)
			{
				settingsBar.localScale = Vector3.Lerp(settingsBar.localScale, new Vector3(PercentageValue, settingsBar.localScale.y, settingsBar.localScale.z), 20f * Time.deltaTime);
				maskRectTransform.sizeDelta = new Vector2(barSizeRectTransform.sizeDelta.x * PercentageValue, maskRectTransform.sizeDelta.y);
			}
			if (SemiFunc.UIMouseHover(parentPage, barSizeRectTransform, menuSelectableElement.menuID, 5f, 5f, (MenuScrollBox)null, (ScrollRect)null))
			{
				if (!hovering)
				{
					MenuManager.instance.MenuEffectHover(SemiFunc.MenuGetPitchFromYPos(rectTransform), -1f);
				}
				hovering = true;
				SemiFunc.MenuSelectionBoxTargetSet(parentPage, barSizeRectTransform, new Vector2(-3f, 0f), new Vector2(20f, 10f));
				if (hasBar)
				{
					PointerLogic();
				}
				else if (XRRayInteractorManager.Instance?.GetTriggerDown() ?? Input.GetMouseButtonDown(0))
				{
					MenuManager.instance.MenuEffectClick((MenuClickEffectType)0, parentPage, -1f, -1f, false);
					OnIncrease();
				}
			}
			else
			{
				hovering = false;
				if (((Component)barPointer).gameObject.activeSelf)
				{
					barPointer.localPosition = new Vector3(-999f, barPointer.localPosition.y, barPointer.localPosition.z);
					((Component)barPointer).gameObject.SetActive(false);
				}
			}
			if (Object.op_Implicit((Object)(object)segmentMaskText) && ((TMP_Text)segmentMaskText).text != ((TMP_Text)segmentText).text)
			{
				((TMP_Text)segmentMaskText).text = ((TMP_Text)segmentText).text;
			}
		}

		private void PointerLogic()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_00a1: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)barPointer))
			{
				return;
			}
			if (!((Component)barPointer).gameObject.activeSelf)
			{
				((Component)barPointer).gameObject.SetActive(true);
			}
			Vector2 val = SemiFunc.UIMouseGetLocalPositionWithinRectTransform(barSizeRectTransform);
			float num = (endValue - startValue) / pointerSegmentJump;
			float num2 = Mathf.Clamp01(val.x / barSizeRectTransform.sizeDelta.x);
			num2 = Mathf.Round(num2 * num) / num;
			float num3 = Mathf.Clamp(((Transform)barSizeRectTransform).localPosition.x + num2 * barSizeRectTransform.sizeDelta.x, ((Transform)barSizeRectTransform).localPosition.x, ((Transform)barSizeRectTransform).localPosition.x + barSizeRectTransform.sizeDelta.x);
			barPointer.localPosition = new Vector3(num3 - 2f, barPointer.localPosition.y, barPointer.localPosition.z);
			if (XRRayInteractorManager.Instance?.GetTriggerButton() ?? Input.GetMouseButton(0))
			{
				prevCurrentValue = currentValue;
				currentValue = Mathf.Lerp(startValue, endValue, num2);
				currentValue = startValue + (float)Mathf.RoundToInt((currentValue - startValue) / pointerSegmentJump) * pointerSegmentJump;
				currentValue = Mathf.Clamp(currentValue, startValue, endValue);
				if (!Mathf.Approximately(prevCurrentValue, currentValue))
				{
					MenuManager.instance.MenuEffectClick((MenuClickEffectType)4, parentPage, -1f, -1f, false);
				}
				int num4 = Mathf.RoundToInt(currentValue);
				if (hasCustomOptions && num4 < customOptions.Count)
				{
					((TMP_Text)segmentText).text = customOptions[num4].customOptionText;
				}
				else
				{
					((TMP_Text)segmentText).text = stringAtStartOfValue + DisplayValue + stringAtEndOfValue;
				}
				if (hasCustomOptions)
				{
					UpdateSegmentTextAndValue();
				}
			}
		}

		private void UpdateSegmentTextAndValue()
		{
			if (hasCustomOptions)
			{
				int num = Mathf.RoundToInt(currentValue);
				if (num < customOptions.Count)
				{
					string text = customOptions[num].customOptionText;
					if (text.Length > 16)
					{
						text = text.Substring(0, 16) + "...";
					}
					((TMP_Text)segmentText).text = text;
				}
			}
			else
			{
				((TMP_Text)segmentText).text = stringAtStartOfValue + DisplayValue + stringAtEndOfValue;
			}
		}

		public void OnIncrease()
		{
			valueChangedImpulse = true;
			if (wrapAround)
			{
				currentValue = (Mathf.Approximately(currentValue, endValue) ? startValue : (currentValue + buttonSegmentJump));
			}
			else
			{
				currentValue += buttonSegmentJump;
			}
			currentValue = startValue + (float)Mathf.RoundToInt((currentValue - startValue) / buttonSegmentJump) * buttonSegmentJump;
			currentValue = Mathf.Clamp(currentValue, startValue, endValue);
			UpdateSegmentTextAndValue();
		}

		public void OnDecrease()
		{
			valueChangedImpulse = true;
			if (wrapAround)
			{
				currentValue = (Mathf.Approximately(currentValue, startValue) ? endValue : (currentValue - buttonSegmentJump));
			}
			else
			{
				currentValue -= buttonSegmentJump;
			}
			currentValue = startValue + (float)Mathf.RoundToInt((currentValue - startValue) / buttonSegmentJump) * buttonSegmentJump;
			currentValue = Mathf.Clamp(currentValue, startValue, endValue);
			UpdateSegmentTextAndValue();
		}

		public void SetBarScaleInstant()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			settingsBar.localScale = new Vector3(PercentageValue, settingsBar.localScale.y, settingsBar.localScale.z);
		}
	}
	public class SettingOption : MonoBehaviour
	{
		public string settingCategory;

		public string settingName;

		public string? settingDisplayName;

		public TextMeshProUGUI settingText;

		public RectTransform rectTransform;

		private void Start()
		{
			((TMP_Text)settingText).text = settingDisplayName ?? Utils.ToHumanReadable(settingName);
		}

		public void FetchBoolOption()
		{
			((Component)this).GetComponent<MenuTwoOptions>().startSettingFetch = (bool)Plugin.Config.File[settingCategory, settingName].BoxedValue;
		}

		public void UpdateBool(bool value)
		{
			Plugin.Config.File[settingCategory, settingName].BoxedValue = value;
		}

		public void UpdateInt(int value)
		{
			Plugin.Config.File[settingCategory, settingName].BoxedValue = value;
		}

		public void UpdateFloat(float value)
		{
			Plugin.Config.File[settingCategory, settingName].BoxedValue = value;
		}

		public void UpdateSlider()
		{
			FloatMenuSlider component = ((Component)this).GetComponent<FloatMenuSlider>();
			if (component.isInteger)
			{
				UpdateInt(Mathf.RoundToInt(component.currentValue));
			}
			else
			{
				UpdateFloat(component.currentValue);
			}
		}
	}
	public class RuntimeSettingOption : MonoBehaviour
	{
		public RectTransform rectTransform;

		public TextMeshProUGUI runtimeText;

		private FloatMenuSlider slider;

		private OpenXR.Runtimes runtimes;

		private void Awake()
		{
			slider = ((Component)this).GetComponent<FloatMenuSlider>();
			runtimes = OpenXR.GetRuntimes();
			slider.hasBar = false;
			slider.wrapAround = true;
			FloatMenuSlider floatMenuSlider = slider;
			List<FloatMenuSlider.CustomOption> list = new List<FloatMenuSlider.CustomOption>();
			list.Add(new FloatMenuSlider.CustomOption
			{
				customOptionText = "System Default"
			});
			list.AddRange(runtimes.Select((OpenXR.Runtime runtime) => new FloatMenuSlider.CustomOption
			{
				customOptionText = runtime.Name
			}));
			floatMenuSlider.customOptions = list;
			slider.currentValue = (runtimes.TryGetRuntimeByPath(Plugin.Config.OpenXRRuntimeFile.Value, out var runtime2) ? (MiscHelpers.IndexOf<OpenXR.Runtime>((IEnumerable<OpenXR.Runtime>)runtimes, runtime2) + 1) : 0);
			UpdateSlider();
		}

		public void UpdateSlider()
		{
			OpenXR.Runtime runtime;
			if (slider.currentValue == 0f)
			{
				Plugin.Config.OpenXRRuntimeFile.Value = "";
				((TMP_Text)runtimeText).text = "System Default";
			}
			else if (runtimes.TryGetRuntime(slider.customOptions[(int)slider.currentValue].customOptionText, out runtime))
			{
				Plugin.Config.OpenXRRuntimeFile.Value = runtime.Path;
				((TMP_Text)runtimeText).text = runtime.Name;
			}
		}
	}
}
namespace RepoXR.UI.Menu
{
	public class InputKeyboard : MonoBehaviour
	{
		public static InputKeyboard instance;

		public MenuTextInput menuInput;

		private NonNativeKeyboard keyboard;

		private float animLerp;

		private bool closing;

		private void Awake()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)instance))
			{
				Object.Destroy((Object)(object)((Component)instance).gameObject);
			}
			instance = this;
			keyboard = ((Component)this).GetComponentInChildren<NonNativeKeyboard>(true);
			keyboard.SubmitOnEnter = false;
			((Component)this).transform.localScale = Vector3.zero;
		}

		private void Start()
		{
			keyboard.OnKeyboardValueKeyPressed += OnKeyPressed;
			keyboard.OnKeyboardFunctionKeyPressed += OnFunctionKeyPressed;
			keyboard.PresentKeyboard();
		}

		private void OnDestroy()
		{
			keyboard.OnKeyboardValueKeyPressed -= OnKeyPressed;
			keyboard.OnKeyboardFunctionKeyPressed -= OnFunctionKeyPressed;
		}

		private void Update()
		{
			//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_008c: Unknown result type (might be due to invalid IL or missing references)
			float num = animLerp;
			if (!(num < 1f) || closing)
			{
				if (num > 0f && closing)
				{
					animLerp -= Time.deltaTime * 4f;
				}
			}
			else
			{
				animLerp += Time.deltaTime * 4f;
			}
			animLerp = Mathf.Clamp01(animLerp);
			((Component)this).transform.localScale = Vector3.LerpUnclamped(Vector3.zero, Vector3.one, AssetCollection.KeyboardAnimation.Evaluate(animLerp));
			if (animLerp == 0f && closing)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		public void Close()
		{
			closing = true;
		}

		private void OnKeyPressed(KeyboardValueKey key)
		{
			MenuTextInput obj = menuInput;
			obj.textCurrent += (keyboard.IsShifted ? key.ShiftValue : key.Value);
		}

		private void OnFunctionKeyPressed(KeyboardKeyFunc key)
		{
			switch (key.ButtonFunction)
			{
			case KeyboardKeyFunc.Function.Backspace:
				menuInput.textCurrent = menuInput.textCurrent.Remove(Mathf.Max(menuInput.textCurrent.Length - 1, 0));
				break;
			case KeyboardKeyFunc.Function.Enter:
			{
				MenuPageServerListCreateNew componentInParent = ((Component)menuInput).GetComponentInParent<MenuPageServerListCreateNew>();
				if (componentInParent != null)
				{
					componentInParent.ButtonConfirm();
					break;
				}
				MenuPageServerListSearch componentInParent2 = ((Component)menuInput).GetComponentInParent<MenuPageServerListSearch>();
				if (componentInParent2 != null)
				{
					componentInParent2.ButtonConfirm();
				}
				break;
			}
			}
		}
	}
	internal static class MenuHelper
	{
		public enum RepoXRMenuPage
		{
			VRSettings = 37449,
			VRSettingsCategory,
			VRShowcase
		}

		public static void RegisterCustomMenus(MenuManager manager)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			manager.menuPages.AddRange(new <>z__ReadOnlyArray<MenuPages>((MenuPages[])(object)new MenuPages[3]
			{
				new MenuPages
				{
					menuPageIndex = (MenuPageIndex)37449,
					menuPage = AssetCollection.MenuSettings
				},
				new MenuPages
				{
					menuPageIndex = (MenuPageIndex)37450,
					menuPage = AssetCollection.MenuSettingsCategory
				},
				new MenuPages
				{
					menuPageIndex = (MenuPageIndex)37451,
					menuPage = AssetCollection.MenuShowcase
				}
			}));
		}

		public static void PageOpenOnTop(RepoXRMenuPage page)
		{
			MenuManager.instance.PageOpenOnTop((MenuPageIndex)page);
		}

		public static MenuPage PageAddOnTop(RepoXRMenuPage page)
		{
			MenuManager.instance.PageAddOnTop((MenuPageIndex)page);
			return MenuManager.instance.addedPagesOnTop.Find((MenuPage p) => (int)p.menuPageIndex == (int)page && (int)p.currentPageState != 2);
		}
	}
	public class SettingsCategoryPage : MonoBehaviour
	{
		public string categoryName;

		public TextMeshProUGUI categoryText;

		public Transform scrollerTransform;

		private void Start()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			((TMP_Text)categoryText).text = categoryName;
			float num = -50f;
			if (categoryName == "General")
			{
				RectTransform rectTransform = Object.Instantiate<GameObject>(AssetCollection.RuntimeSetting, scrollerTransform).GetComponent<RuntimeSettingOption>().rectTransform;
				rectTransform.anchoredPosition += new Vector2(0f, num);
				num -= 30f;
			}
			foreach (var (val3, val4) in Plugin.Config.File)
			{
				if (val3.Section != categoryName)
				{
					continue;
				}
				PropertyInfo propertyInfo = AccessTools.Property(typeof(Config), val3.Key);
				if ((object)propertyInfo == null)
				{
					continue;
				}
				ConfigDescriptorAttribute customAttribute = propertyInfo.GetCustomAttribute<ConfigDescriptorAttribute>();
				if (customAttribute == null)
				{
					continue;
				}
				SettingOption component = ((val4.SettingType == typeof(bool)) ? Object.Instantiate<GameObject>(AssetCollection.BoolSetting, scrollerTransform) : Object.Instantiate<GameObject>(AssetCollection.SliderSetting, scrollerTransform)).GetComponent<SettingOption>();
				component.settingCategory = categoryName;
				component.settingName = val3.Key;
				component.settingDisplayName = customAttribute.CustomName;
				RectTransform rectTransform2 = component.rectTransform;
				rectTransform2.anchoredPosition += new Vector2(0f, num);
				MenuTwoOptions component2 = ((Component)component).GetComponent<MenuTwoOptions>();
				if (component2 != null)
				{
					((Behaviour)component2).enabled = true;
				}
				if (val4.SettingType == typeof(bool))
				{
					MenuTwoOptions component3 = ((Component)component).GetComponent<MenuTwoOptions>();
					component3.option1Text = customAttribute.TrueText;
					component3.option2Text = customAttribute.FalseText;
				}
				else if (val4.SettingType != typeof(bool))
				{
					FloatMenuSlider component4 = ((Component)component).GetComponent<FloatMenuSlider>();
					component4.displayPercentage = customAttribute.Percentage;
					component4.stringAtEndOfValue = (customAttribute.Percentage ? "%" : customAttribute.Suffix);
					component4.buttonSegmentJump = customAttribute.StepSize;
					component4.pointerSegmentJump = customAttribute.PointerSize;
					if (val4.SettingType.IsEnum)
					{
						string[] names = Enum.GetNames(val4.SettingType);
						foreach (string input in names)
						{
							component4.customOptions.Add(new FloatMenuSlider.CustomOption
							{
								customOptionText = Utils.ToHumanReadable(input)
							});
						}
						component4.hasCustomOptions = true;
						component4.currentValue = (int)val4.BoxedValue;
						component4.isInteger = true;
						component4.hasBar = !customAttribute.EnumDisableBar;
						component4.wrapAround = true;
						num -= 30f;
						continue;
					}
					AcceptableValueBase acceptableValues = val4.Description.AcceptableValues;
					if (!(acceptableValues is AcceptableValueRange<float> val5))
					{
						if (!(acceptableValues is AcceptableValueRange<int> val6))
						{
							num -= 30f;
							continue;
						}
						component4.startValue = val6.MinValue;
						component4.endValue = val6.MaxValue;
						component4.currentValue = (int)val4.BoxedValue;
						component4.isInteger = true;
					}
					else
					{
						component4.startValue = val5.MinValue;
						component4.endValue = val5.MaxValue;
						component4.currentValue = (float)val4.BoxedValue;
					}
				}
				num -= 30f;
			}
		}
	}
	public class SettingsPage : MonoBehaviour
	{
		private void Start()
		{
			MenuManager.instance.PageCloseAllAddedOnTop();
			MenuHelper.PageAddOnTop(MenuHelper.RepoXRMenuPage.VRShowcase);
		}

		public void ButtonEventOpenCategory(string category)
		{
			MenuManager.instance.PageCloseAllAddedOnTop();
			((Component)MenuHelper.PageAddOnTop(MenuHelper.RepoXRMenuPage.VRSettingsCategory)).GetComponent<SettingsCategoryPage>().categoryName = category;
		}

		public void ButtonEventBack()
		{
			if ((Object)(object)RunManager.instance.levelCurrent == (Object)(object)RunManager.instance.levelMainMenu)
			{
				MenuManager.instance.PageCloseAllExcept((MenuPageIndex)0);
				MenuManager.instance.PageSetCurrent((MenuPageIndex)0, MenuPageMain.instance.menuPage);
			}
			else if ((Object)(object)RunManager.instance.levelCurrent == (Object)(object)RunManager.instance.levelLobbyMenu)
			{
				MenuManager.instance.PageCloseAllExcept((MenuPageIndex)8);
				MenuManager.instance.PageSetCurrent((MenuPageIndex)8, MenuPageLobby.instance.menuPage);
			}
			else
			{
				MenuManager.instance.PageCloseAll();
				MenuManager.instance.PageOpen((MenuPageIndex)1, false);
			}
		}
	}
	public class ShowcasePage : MonoBehaviour
	{
		public TextMeshProUGUI versionText;

		public TextMeshProUGUI commitText;

		private void Awake()
		{
			((TMP_Text)versionText).text = "v1.2.2";
			((TMP_Text)commitText).text = "Commit: " + Plugin.GetCommitHash();
		}

		public void MadeByClicked()
		{
			Application.OpenURL("https://github.com/DaXcess");
		}

		public void GitHubClicked()
		{
			Application.OpenURL("https://github.com/DaXcess/RepoXR");
		}

		public void DiscordClicked()
		{
			Application.OpenURL("https://discord.gg/2DxNgpPZUF");
		}

		public void KoFiClicked()
		{
			Application.OpenURL("https://ko-fi.com/daxcess");
		}
	}
}
namespace RepoXR.UI.Expressions
{
	public class ExpressionRadial : MonoBehaviour
	{
		public static ExpressionRadial instance;

		public Transform handTransform;

		[SerializeField]
		protected AnimationCurve animationCurve;

		[SerializeField]
		protected Transform canvasTransform;

		[SerializeField]
		protected Transform previewTransform;

		[SerializeField]
		protected Image previewBackground;

		[SerializeField]
		protected ExpressionPart[] parts;

		private PlayerExpression playerExpression;

		private HapticManager.Hand currentHand = HapticManager.Hand.Both;

		internal bool isActive;

		private bool isOverridden;

		private float animationLerp;

		private float overrideAnimationLerp = 1f;

		private int hoveredPart = -1;

		internal bool closedLastPress;

		private void Awake()
		{
			instance = this;
			((Component)PlayerExpressionsUI.instance).transform.SetParent(previewTransform, false);
			playerExpression = PlayerExpressionsUI.instance.playerExpression;
			ReloadParts();
		}

		private void OnDestroy()
		{
			instance = null;
		}

		private void Update()
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Invalid comparison between Unknown and I4
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: 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_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			UpdateBindingHand();
			if (currentHand == HapticManager.Hand.Both)
			{
				return;
			}
			if (closedLastPress)
			{
				closedLastPress = false;
			}
			if (VRInputSystem.Instance.ExpressionPressed() || (isActive && SemiFunc.InputDown((InputKey)7)))
			{
				if (!isActive)
				{
					isActive = true;
					ResetPosition();
					if ((int)ChatManager.instance.chatState == 1)
					{
						ChatManager.instance.StateSet((ChatState)0);
					}
					MenuManager.instance.MenuEffectClick((MenuClickEffectType)1, (MenuPage)null, -1f, -1f, true);
				}
				else if (isActive)
				{
					isActive = false;
					closedLastPress = true;
					MenuManager.instance.MenuEffectClick((MenuClickEffectType)0, (MenuPage)null, -1f, -1f, true);
				}
			}
			if (isActive)
			{
				((SemiUI)PlayerExpressionsUI.instance).Show();
			}
			animationLerp += Time.deltaTime * (float)((isActive || isOverridden) ? 4 : (-4));
			animationLerp = Mathf.Clamp01(animationLerp);
			overrideAnimationLerp += Time.deltaTime * (float)((!isActive && isOverridden) ? (-4) : 4);
			overrideAnimationLerp = Mathf.Clamp01(overrideAnimationLerp);
			((Component)this).transform.localScale = Vector3.LerpUnclamped(Vector3.zero, Vector3.one, animationCurve.Evaluate(animationLerp));
			CollectionExtensions.Do<ExpressionPart>((IEnumerable<ExpressionPart>)parts, (Action<ExpressionPart>)delegate(ExpressionPart part)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				((Component)part).transform.localScale = Vector3.LerpUnclamped(Vector3.zero, Vector3.one, animationCurve.Evaluate(overrideAnimationLerp));
			});
			bool flag = DataManager.instance.activeExpressions.Count > 0 || playerExpression.overrideExpressions.Count > 0;
			Color val = SemiFunc.PlayerGetColorMain(PlayerAvatar.instance);
			((Graphic)previewBackground).color = Color.Lerp(((Graphic)previewBackground).color, new Color(val.r, val.g, val.b, 0.003921569f * (float)(flag ? 50 : 0)), 8f * Time.deltaTime);
			OverrideLogic();
			HoverLogic();
			ActivateLogic();
		}

		public static bool ExpressionActive(InputKey input)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Expected I4, but got Unknown
			ExpressionPart.Expression item = (ExpressionPart.Expression)(input - 26);
			return DataManager.instance.activeExpressions.Contains(item);
		}

		private void ResetPosition(bool overrideOnly = false)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_0082: 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_0092: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)CameraUtils.Instance.MainCamera).transform;
			if (isActive)
			{
				if (overrideOnly)
				{
					return;
				}
				((Component)this).transform.position = handTransform.position;
				((Component)this).transform.LookAt(transform.position);
			}
			if (overrideOnly)
			{
				PlayerExpressionsUI val = PlayerExpressionsUI.instance;
				Vector3 forward = transform.forward;
				float num = ((!val.shrinkActive) ? (val.shrinkCurve.Evaluate(val.shrinkLerp) * -0.15f) : 0f);
				((Component)this).transform.position = transform.position + forward * 0.5f + transform.up * (-0.15f + num);
				((Component)this).transform.LookAt(transform.position);
			}
		}

		private void ReloadParts()
		{
			ExpressionPart[] array = parts;
			foreach (ExpressionPart expressionPart in array)
			{
				expressionPart.SetActive(DataManager.instance.activeExpressions.Contains(expressionPart.expression));
			}
		}

		private void UpdateBindingHand()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Max(InputActionRebindingExtensions.GetBindingIndex(Actions.Instance["Chat"], VRInputSystem.Instance.CurrentControlScheme, (string)null), 0);
			InputBinding val = Actions.Instance["Chat"].bindings[num];
			if (Utils.GetControlHand(((InputBinding)(ref val)).effectivePath, out var hand) && currentHand != hand)
			{
				currentHand = hand;
				handTransform = ((hand == HapticManager.Hand.Left) ? VRSession.Instance.Player.Rig.leftArmTarget : VRSession.Instance.Player.Rig.rightArmTarget);
			}
		}

		private void OverrideLogic()
		{
			isOverridden = playerExpression.overrideExpressions.Count > 0;
			if (isOverridden)
			{
				ResetPosition(overrideOnly: true);
			}
		}

		private void HoverLogic()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if (isActive)
			{
				Vector3 val = Vector3.ProjectOnPlane(handTransform.position - canvasTransform.position, canvasTransform.forward);
				float num = Vector3.SignedAngle(canvasTransform.up, val, -canvasTransform.forward);
				if (num < 0f)
				{
					num += 360f;
				}
				int num2 = (int)num * parts.Length / 360;
				if (num2 != hoveredPart)
				{
					HapticManager.Impulse(currentHand, HapticManager.Type.Impulse, 0.03f);
				}
				hoveredPart = num2;
				for (int i = 0; i < parts.Length; i++)
				{
					parts[i].SetHovered(i == hoveredPart);
				}
			}
		}

		private void ActivateLogic()
		{
			if (!isActive || hoveredPart < 0 || playerExpression.overrideExpressions.Any((OverrideExpression expr) => expr.index - 1 == hoveredPart) || Object.op_Implicit((Object)(object)MenuManager.instance.currentMenuPage))
			{
				return;
			}
			string name = ((currentHand == HapticManager.Hand.Left) ? "ExpressionLeft" : "ExpressionRight");
			if (Actions.Instance[name].WasPressedThisFrame())
			{
				MenuManager.instance.MenuEffectClick((MenuClickEffectType)4, (MenuPage)null, -1f, -1f, true);
				HapticManager.Impulse(currentHand, HapticManager.Type.Impulse);
				ExpressionPart expressionPart = parts[hoveredPart];
				if (expressionPart.Toggle())
				{
					DataManager.instance.activeExpressions.Add(expressionPart.expression);
				}
				else
				{
					DataManager.instance.activeExpressions.Remove(expressionPart.expression);
				}
			}
		}
	}
	public class ExpressionPart : MonoBehaviour
	{
		public enum Expression
		{
			Angry,
			Sad,
			Suspicious,
			EyesClosed,
			Crazy,
			Happy
		}

		public Expression expression;

		public AnimationCurve triggerAnimation;

		private Image background;

		private TextMeshProUGUI text;

		private PlayerExpression playerExpression;

		private Vector3 currentScale;

		private bool isHovered;

		private bool isActive;

		private float animTimer = 1f;

		private void Awake()
		{
			background = ((Component)this).GetComponent<Image>();
			text = ((Component)this).GetComponentInChildren<TextMeshProUGUI>();
			playerExpression = PlayerExpressionsUI.instance.playerExpression;
		}

		private void Update()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_0089: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: 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_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			Color val = SemiFunc.PlayerGetColorMain(PlayerAvatar.instance);
			bool flag = isActive || playerExpression.overrideExpressions.Any((OverrideExpression expr) => expr.index - 1 == (int)expression);
			Color val2 = (flag ? Utils.GetTextColor(val) : Utils.GetTextColor(val, 0.6f, 0.85f));
			Color val3 = (flag ? Color.Lerp(val, Color.white, 0.4f) : (isHovered ? Color.Lerp(val, Color.white, 0.2f) : Color.Lerp(val, Color.black, 0.2f)));
			val2.a = (flag ? 1f : 0.85f);
			val3.a = (flag ? 0.5f : (isHovered ? 0.3f : 0.2f));
			((Graphic)text).color = Color.Lerp(((Graphic)text).color, val2, 8f * Time.deltaTime);
			((Graphic)background).color = Color.Lerp(((Graphic)background).color, val3, 8f * Time.deltaTime);
			currentScale = Vector3.Lerp(currentScale, Vector3.one * (isHovered ? 1.1f : 1f), 8f * Time.deltaTime);
			Vector3 val4 = currentScale;
			if (animTimer < 1f)
			{
				animTimer += Time.deltaTime * 4f;
				animTimer = Mathf.Clamp01(animTimer);
				Vector3 val5 = Vector3.one * (triggerAnimation.Evaluate(animTimer) * 0.15f);
				val4 += (flag ? val5 : (-val5));
			}
			if (ExpressionRadial.instance.isActive)
			{
				((Component)this).transform.localScale = val4;
			}
		}

		public void SetHovered(bool hovered)
		{
			isHovered = hovered;
		}

		public bool Toggle()
		{
			isActive = !isActive;
			animTimer = 0f;
			return isActive;
		}

		public void SetActive(bool active)
		{
			isActive = active;
		}
	}
}
namespace RepoXR.UI.Controls
{
	public class ControlOption : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <RebindTimer>d__17 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ControlOption <>4__this;

			private int <i>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <RebindTimer>d__17(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Expected O, but got Unknown
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Expected O, but got Unknown
				int num = <>1__state;
				ControlOption controlOption = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 5;
					break;
				case 1:
					<>1__state = -1;
					((TMP_Text)controlOption.controlText).text = $"[. {<i>5__2} .]";
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<i>5__2--;
					break;
				}
				if (<i>5__2 >= 0)
				{
					((TMP_Text)controlOption.controlText).text = $"[ .{<i>5__2}. ]";
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[SerializeField]
		protected TextMeshProUGUI controlName;

		[SerializeField]
		protected TextMeshProUGUI controlText;

		private PlayerInput playerInput;

		private RebindManager manager;

		private RemappableControl control;

		private Coroutine? rebindTimerCoroutine;

		private int bindingIndex;

		public InputAction? action
		{
			get
			{
				RemappableControl remappableControl = control;
				if (remappableControl == null)
				{
					return null;
				}
				return remappableControl.currentInput.action;
			}
		}

		private void Awake()
		{
			playerInput = VRInputSystem.Instance.GetPlayerInput();
		}

		public void StartRebind()
		{
			manager.StartRebind(this, bindingIndex);
		}

		public void DeleteBinding()
		{
			if (!string.IsNullOrEmpty(playerInput.currentControlScheme))
			{
				InputActionRebindingExtensions.ApplyBindingOverride(action, bindingIndex, "");
				ReloadBinding();
				manager.SaveBindings();
			}
		}

		public void SetBindToggle(bool toggle)
		{
			VRInputSystem.Instance.InputToggleRebind(action.name, toggle);
		}

		public void FetchToggle()
		{
			if (action != null)
			{
				((Component)this).GetComponentInChildren<MenuTwoOptions>().startSettingFetch = VRInputSystem.Instance.InputToggleGet(action.name);
			}
		}

		public void Setup(RebindManager rebindManager, RemappableControl remappableControl)
		{
			manager = rebindManager;
			control = remappableControl;
			((TMP_Text)controlName).text = control.controlName;
		}

		public void ReloadBinding()
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			if (rebindTimerCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(rebindTimerCoroutine);
			}
			bindingIndex = Mathf.Max(control.bindingIndex, 0) + Mathf.Max(InputActionRebindingExtensions.GetBindingIndex(control.currentInput.action, playerInput.currentControlScheme, (string)null), 0);
			if (string.IsNullOrEmpty(playerInput.currentControlScheme))
			{
				((TMP_Text)controlText).text = "<sprite=37> DISCONNECTED";
				return;
			}
			InputBinding val = control.currentInput.action.bindings[bindingIndex];
			string effectivePath = ((InputBinding)(ref val)).effectivePath;
			if (string.IsNullOrEmpty(effectivePath))
			{
				((TMP_Text)controlText).text = "NOT BOUND";
			}
			else
			{
				((TMP_Text)controlText).text = Utils.GetControlSpriteString(effectivePath);
			}
		}

		public void StartRebindTimer()
		{
			rebindTimerCoroutine = ((MonoBehaviour)this).StartCoroutine(RebindTimer());
		}

		[IteratorStateMachine(typeof(<RebindTimer>d__17))]
		private IEnumerator RebindTimer()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RebindTimer>d__17(0)
			{
				<>4__this = this
			};
		}
	}
	public class VRMenuKeybindToggle : MonoBehaviour
	{
		public string inputAction;

		public void EnableToggle()
		{
			VRInputSystem.Instance.InputToggleRebind(inputAction, toggle: true);
		}

		public void DisableToggle()
		{
			VRInputSystem.Instance.InputToggleRebind(inputAction, toggle: false);
		}

		public void FetchSetting()
		{
			((Component)this).GetComponent<MenuTwoOptions>().startSettingFetch = VRInputSystem.Instance.InputToggleGet(inputAction);
		}
	}
}
namespace RepoXR.ThirdParty.MRTK
{
	public class CapsLockHighlight : MonoBehaviour
	{
		[SerializeField]
		private Image m_Highlight;

		private NonNativeKeyboard m_Keyboard;

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

		private void Update()
		{
			UpdateState();
		}

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

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

		private NonNativeKeyboard m_Keyboard;

		public Function ButtonFunction => buttonFunction;

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

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

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

		public string ShiftValue;

		private TextMeshProUGUI m_Text;

		private Button m_Button;

		private NonNativeKeyboard m_Keyboard;

		private void Awake()
		{
			m_Keyboard = ((Component)this).GetComponentInParent<NonNativeKeyboard>();
			m_Button = ((Component)this).GetComponent<Button>();
		}

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

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

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

		public TMP_InputField InputField;

		public bool SliderEnabled = true;

		public bool SubmitOnEnter = true;

		public Image AlphaKeyboard;

		public Image SymbolKeyboard;

		public Image AlphaSubKeys;

		public Image AlphaWebKeys;

		public Image AlphaMailKeys;

		private LayoutType m_LastKeyboardLayout;

		[Header("Positioning")]
		[SerializeField]
		private float m_MaxScale = 1f;

		[SerializeField]
		private float m_MinScale = 1f;

		[SerializeField]
		private float m_MaxDistance = 3.5f;

		[SerializeField]
		private float m_MinDistance = 0.25f;

		public bool CloseOnInactivity = true;

		public float CloseOnInactivityTime = 15f;

		private float _closingTime;

		private bool m_IsShifted;

		private bool m_IsCapslocked;

		private int m_CaretPosition;

		private Vector3 m_StartingScale = Vector3.one;

		private Vector3 m_ObjectBounds;

		private Color _defaultColor;

		private Image _recordImage;

		private AudioSource _audioSource;

		public bool IsShifted => m_IsShifted;

		public bool IsCapsLocked => m_IsCapslocked;

		public event EventHandler OnTextSubmitted = delegate
		{
		};

		public event Action<string> OnTextUpdated = delegate
		{
		};

		public event EventHandler OnClosed = delegate
		{
		};

		public event EventHandler OnPrevious = delegate
		{
		};

		public event EventHandler OnNext = delegate
		{
		};

		public event EventHandler OnPlacement = delegate
		{
		};

		public event Action<bool> OnKeyboardShifted = delegate
		{
		};

		public event Action<KeyboardValueKey> OnKeyboardValueKeyPressed = delegate
		{
		};

		public event Action<KeyboardKeyFunc> OnKeyboardFunctionKeyPressed = delegate
		{
		};

		private void Awake()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			m_StartingScale = ((Component)this).transform.localScale;
			Bounds val = RectTransformUtility.CalculateRelativeRectTransformBounds(((Component)this).transform);
			RectTransform component = ((Component)this).GetComponent<RectTransform>();
			m_ObjectBounds = new Vector3(((Bounds)(ref val)).size.x * ((Transform)component).localScale.x, ((Bounds)(ref val)).size.y * ((Transform)component).localScale.y, ((Bounds)(ref val)).size.z * ((Transform)component).localScale.z);
			InputField.keyboardType = (TouchScreenKeyboardType)int.MaxValue;
			((Component)this).gameObject.SetActive(false);
		}

		protected void Start()
		{
			((UnityEvent<string>)(object)InputField.onValueChanged).AddListener((UnityAction<string>)DoTextUpdated);
		}

		private void DoTextUpdated(string value)
		{
			this.OnTextUpdated?.Invoke(value);
		}

		private void LateUpdate()
		{
			CheckForCloseOnInactivityTimeExpired();
		}

		private void UpdateCaretPosition(int newPos)
		{
			InputField.caretPosition = newPos;
		}

		protected void OnDisable()
		{
			m_LastKeyboardLayout = LayoutType.Alpha;
			Clear();
		}

		public void PresentKeyboard()
		{
			ResetClosingTime();
			((Component)this).gameObject.SetActive(true);
			ActivateSpecificKeyboard(LayoutType.Alpha);
			this.OnPlacement(this, EventArgs.Empty);
		}

		public void PresentKeyboard(string startText)
		{
			PresentKeyboard();
			Clear();
			InputField.text = startText;
		}

		public void PresentKeyboard(LayoutType keyboardType)
		{
			PresentKeyboard();
			ActivateSpecificKeyboard(keyboardType);
		}

		public void PresentKeyboard(string startText, LayoutType keyboardType)
		{
			PresentKeyboard(startText);
			ActivateSpecificKeyboard(keyboardType);
		}

		public void RepositionKeyboard(Vector3 kbPos, float verticalOffset = 0f)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.position = kbPos;
			ScaleToSize();
			LookAtTargetOrigin();
		}

		public void RepositionKeyboard(Transform objectTransform, BoxCollider aCollider = null, float verticalOffset = 0f)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.position = objectTransform.position;
			if ((Object)(object)aCollider != (Object)null)
			{
				Bounds bounds = ((Collider)aCollider).bounds;
				float num = 0f - (((Bounds)(ref bounds)).size.y * 0.5f + verticalOffset);
				((Component)this).transform.Translate(0f, num, -0.6f, objectTransform);
			}
			else
			{
				float num2 = 0f - (m_ObjectBounds.y * 0.5f + verticalOffset);
				((Component)this).transform.Translate(0f, num2, -0.6f, objectTransform);
			}
			ScaleToSize();
			LookAtTargetOrigin();
		}

		private void ScaleToSize()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((Component)this).transform.position - ((Component)Camera.main).transform.position;
			float magnitude = ((Vector3)(ref val)).magnitude;
			float num = (magnitude - m_MinDistance) / (m_MaxDistance - m_MinDistance);
			float num2 = m_MinScale + (m_MaxScale - m_MinScale) * num;
			num2 = Mathf.Clamp(num2, m_MinScale, m_MaxScale);
			((Component)this).transform.localScale = m_StartingScale * num2;
			Debug.LogFormat("Setting scale: {0} for distance: {1}", new object[2] { num2, magnitude });
		}

		private void LookAtTargetOrigin()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.LookAt(((Component)Camera.main).transform.position);
			((Component)this).transform.Rotate(Vector3.up, 180f);
		}

		private void ActivateSpecificKeyboard(LayoutType keyboardType)
		{
			DisableAllKeyboards();
			ResetKeyboardState();
			switch (keyboardType)
			{
			case LayoutType.URL:
				ShowAlphaKeyboard();
				TryToShowURLSubkeys();
				break;
			case LayoutType.Email:
				ShowAlphaKeyboard();
				TryToShowEmailSubkeys();
				break;
			case LayoutType.Symbol:
				ShowSymbolKeyboard();
				break;
			default:
				ShowAlphaKeyboard();
				TryToShowAlphaSubkeys();
				break;
			}
		}

		private bool IsMicrophoneActive()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return ((Graphic)_recordImage).color != _defaultColor;
		}

		public void AppendValue(KeyboardValueKey valueKey)
		{
			IndicateActivity();
			this.OnKeyboardValueKeyPressed(valueKey);
			if (!m_IsCapslocked)
			{
				Shift(newShiftState: false);
			}
		}

		public void FunctionKey(KeyboardKeyFunc functionKey)
		{
			IndicateActivity();
			this.OnKeyboardFunctionKeyPressed(functionKey);
			switch (functionKey.ButtonFunction)
			{
			case KeyboardKeyFunc.Function.Enter:
				Enter();
				break;
			case KeyboardKeyFunc.Function.Tab:
				Tab();
				break;
			case KeyboardKeyFunc.Function.ABC:
				ActivateSpecificKeyboard(m_LastKeyboardLayout);
				break;
			case KeyboardKeyFunc.Function.Symbol:
				ActivateSpecificKeyboard(LayoutType.Symbol);
				break;
			case KeyboardKeyFunc.Function.Previous:
				MoveCaretLeft();
				break;
			case KeyboardKeyFunc.Function.Next:
				MoveCaretRight();
				break;
			case KeyboardKeyFunc.Function.Close:
				Close();
				break;
			case KeyboardKeyFunc.Function.Shift:
				Shift(!m_IsShifted);
				break;
			case KeyboardKeyFunc.Function.CapsLock:
				CapsLock(!m_IsCapslocked);
				break;
			case KeyboardKeyFunc.Function.Space:
				Space();
				break;
			case KeyboardKeyFunc.Function.Backspace:
				Backspace();
				break;
			case KeyboardKeyFunc.Function.UNDEFINED:
				Debug.LogErrorFormat("The {0} key on this keyboard hasn't been assigned a function.", new object[1] { ((Object)functionKey).name });
				break;
			default:
				throw new ArgumentOutOfRangeException();
			}
		}

		public void Backspace()
		{
			if (InputField.selectionFocusPosition != InputField.caretPosition || InputField.selectionAnchorPosition != InputField.caretPosition)
			{
				if (InputField.selectionAnchorPosition > InputField.selectionFocusPosition)
				{
					InputField.text = InputField.text.Substring(0, InputField.selectionFocusPosition) + InputField.text.Substring(InputField.selectionAnchorPosition);
					InputField.caretPosition = InputField.selectionFocusPosition;
				}
				else
				{
					InputField.text = InputField.text.Substring(0, InputField.selectionAnchorPosition) + InputField.text.Substring(InputField.selectionFocusPosition);
					InputField.caretPosition = InputField.selectionAnchorPosition;
				}
				m_CaretPosition = InputField.caretPosition;
				InputField.selectionAnchorPosition = m_CaretPosition;
				InputField.selectionFocusPosition = m_CaretPosition;
			}
			else
			{
				m_CaretPosition = InputField.caretPosition;
				if (m_CaretPosition > 0)
				{
					m_CaretPosition--;
					InputField.text = InputField.text.Remove(m_CaretPosition, 1);
					UpdateCaretPosition(m_CaretPosition);
				}
			}
		}

		public void Previous()
		{
			this.OnPrevious(this, EventArgs.Empty);
		}

		public void Next()
		{
			this.OnNext(this, EventArgs.Empty);
		}

		public void Enter()
		{
			if (SubmitOnEnter)
			{
				this.OnTextSubmitted?.Invoke(this, EventArgs.Empty);
				Close();
			}
		}

		public void Shift(bool newShiftState)
		{
			m_IsShifted = newShiftState;
			this.OnKeyboardShifted(m_IsShifted);
			if (m_IsCapslocked && !newShiftState)
			{
				m_IsCapslocked = false;
			}
		}

		public void CapsLock(bool newCapsLockState)
		{
			m_IsCapslocked = newCapsLockState;
			Shift(newCapsLockState);
		}

		public void Space()
		{
			m_CaretPosition = InputField.caretPosition;
			UpdateCaretPosition(m_CaretPosition);
		}

		public void Tab()
		{
			string text = "\t";
			m_CaretPosition = InputField.caretPosition;
			InputField.text = InputField.text.Insert(m_CaretPosition, text);
			m_CaretPosition += text.Length;
			UpdateCaretPosition(m_CaretPosition);
		}

		public void MoveCaretLeft()
		{
			m_CaretPosition = InputField.caretPosition;
			if (m_CaretPosition > 0)
			{
				m_CaretPosition--;
				UpdateCaretPosition(m_CaretPosition);
			}
		}

		public void MoveCaretRight()
		{
			m_CaretPosition = InputField.caretPosition;
			if (m_CaretPosition < InputField.text.Length)
			{
				m_CaretPosition++;
				UpdateCaretPosition(m_CaretPosition);
			}
		}

		public void Close()
		{
			this.OnClosed(this, EventArgs.Empty);
			((Component)this).gameObject.SetActive(false);
		}

		public void Clear()
		{
			ResetKeyboardState();
			InputField.text = "";
		}

		public void SetScaleSizeValues(float minScale, float maxScale, float minDistance, float maxDistance)
		{
			m_MinScale = minScale;
			m_MaxScale = maxScale;
			m_MinDistance = minDistance;
			m_MaxDistance = maxDistance;
		}

		public void ShowAlphaKeyboard()
		{
			((Component)AlphaKeyboard).gameObject.SetActive(true);
			m_LastKeyboardLayout = LayoutType.Alpha;
		}

		private bool TryToShowAlphaSubkeys()
		{
			if (((UIBehaviour)AlphaKeyboard).IsActive())
			{
				((Component)AlphaSubKeys).gameObject.SetActive(true);
				return true;
			}
			return false;
		}

		private bool TryToShowEmailSubkeys()
		{
			if (!((UIBehaviour)AlphaKeyboard).IsActive())
			{
				return false;
			}
			((Component)AlphaMailKeys).gameObject.SetActive(true);
			m_LastKeyboardLayout = LayoutType.Email;
			return true;
		}

		private bool TryToShowURLSubkeys()
		{
			if (!((UIBehaviour)AlphaKeyboard).IsActive())
			{
				return false;
			}
			((Component)AlphaWebKeys).gameObject.SetActive(true);
			m_LastKeyboardLayout = LayoutType.URL;
			return true;
		}

		public void ShowSymbolKeyboard()
		{
			((Component)SymbolKeyboard).gameObject.SetActive(true);
		}

		private void DisableAllKeyboards()
		{
			((Component)AlphaKeyboard).gameObject.SetActive(false);
			((Component)SymbolKeyboard).gameObject.SetActive(false);
			((Component)AlphaWebKeys).gameObject.SetActive(false);
			((Component)AlphaMailKeys).gameObject.SetActive(false);
			((Component)AlphaSubKeys).gameObject.SetActive(false);
		}

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

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

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

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

		[SerializeField]
		private Image m_ImageField;

		[SerializeField]
		private Color m_DisabledColor = Color.grey;

		private Color m_StartingColor = Color.white;

		private Button m_Button;

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

		private void Update()
		{
			UpdateState();
		}

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

		[SerializeField]
		private Button m_PageFwd;

		private NonNativeKeyboard m_Keyboard;

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

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

		[SerializeField]
		private float maxHeight = -1f;

		[SerializeField]
		private float horizontalSpacing;

		[SerializeField]
		private float verticalSpacing;

		private RectTransform rectTransform;

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

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

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

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

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

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

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

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

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

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

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

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

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

		private CustomVignette vignette;

		private void Start()
		{
			postProcessing = ((Component)this).GetComponent<PostProcessing>();
			vignette = ScriptableObject.CreateInstance<CustomVignette>();
			((ParameterOverride)vignette.color).overrideState = true;
			((ParameterOverride)vignette.intensity).overrideState = true;
			((ParameterOverride)vignette.smoothness).overrideState = true;
			((ParameterOverride<bool>)(object)((PostProcessEffectSettings)vignette).enabled).value = true;
			postProcessing.volume.profile.AddSettings((PostProcessEffectSettings)(object)vignette);
			((ParameterOverride<bool>)(object)((PostProcessEffectSettings)postProcessing.vignette).enabled).value = false;
			((ParameterOverride<bool>)(object)((PostProcessEffectSettings)((Component)postProcessing).GetComponent<PostProcessVolume>().profile.GetSetting<AmbientOcclusion>()).enabled).value = false;
		}

		private void Update()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			((ParameterOverride<Color>)(object)vignette.color).value = ((ParameterOverride<Color>)(object)postProcessing.vignette.color).value;
			((ParameterOverride<float>)(object)vignette.intensity).value = ((ParameterOverride<float>)(object)postProcessing.vignette.intensity).value;
			((ParameterOverride<float>)(object)vignette.smoothness).value = ((ParameterOverride<float>)(object)postProcessing.vignette.smoothness).value;
		}
	}
	[Serializable]
	[PostProcess(/*Could not decode attribute arguments.*/)]
	public class CustomVignette : PostProcessEffectSettings
	{
		[Tooltip("Vignette color.")]
		public ColorParameter color;

		[Range(0f, 1f)]
		[Tooltip("Amount of vignetting on screen.")]
		public FloatParameter intensity;

		[Range(0.01f, 1f)]
		[Tooltip("Smoothness of the vignette borders.")]
		public FloatParameter smoothness;

		[Range(0f, 1f)]
		[Tooltip("Lower values will make a square-ish vignette.")]
		public FloatParameter roundness;

		[Tooltip("Set to true to mark the vignette to be perfectly round. False will make its shape dependent on the current aspect ratio.")]
		public BoolParameter rounded;

		public override bool IsEnabledAndSupported(PostProcessRenderContext context)
		{
			if (((ParameterOverride<bool>)(object)base.enabled).value && ((ParameterOverride<float>)(object)intensity).value > 0f)
			{
				return Plugin.Config.Vignette.Value;
			}
			return false;
		}

		public CustomVignette()
		{
			//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_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0040: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0056: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_006c: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_007e: Expected O, but got Unknown
			ColorParameter val = new ColorParameter();
			((ParameterOverride<Color>)val).value = new Color(0f, 0f, 0f, 1f);
			color = val;
			FloatParameter val2 = new FloatParameter();
			((ParameterOverride<float>)val2).value = 0f;
			intensity = val2;
			FloatParameter val3 = new FloatParameter();
			((ParameterOverride<float>)val3).value = 0.2f;
			smoothness = val3;
			FloatParameter val4 = new FloatParameter();
			((ParameterOverride<float>)val4).value = 1f;
			roundness = val4;
			BoolParameter val5 = new BoolParameter();
			((ParameterOverride<bool>)val5).value = false;
			rounded = val5;
			((PostProcessEffectSettings)this)..ctor();
		}
	}
	[Preserve]
	public class CustomVignetteRenderer : PostProcessEffectRenderer<CustomVignette>
	{
		private static readonly int VignetteColor = Shader.PropertyToID("_Vignette_Color");

		private static readonly int VignetteSettings = Shader.PropertyToID("_Vignette_Settings");

		public override void Render(PostProcessRenderContext context)
		{
			//IL_0055: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			PropertySheet val = context.propertySheets.Get(AssetCollection.VignetteShader);
			float num = (1f - ((ParameterOverride<float>)(object)base.settings.roundness).value) * 6f + ((ParameterOverride<float>)(object)base.settings.roundness).value;
			val.properties.SetColor(VignetteColor, ((ParameterOverride<Color>)(object)base.settings.color).value);
			val.properties.SetVector(VignetteSettings, new Vector4(((ParameterOverride<float>)(object)base.settings.intensity).value * 3f, ((ParameterOverride<float>)(object)base.settings.smoothness).value * 5f, num, ((ParameterOverride<bool>)(object)base.settings.rounded).value ? 1f : 0f));
			RuntimeUtilities.BlitFullscreenTriangle(context.command, context.source, context.destination, val, 0, false, (Rect?)null, false);
		}
	}
}
namespace RepoXR.Player
{
	public class VREyeTracking : MonoBehaviour
	{
		private Transform debugCube;

		private Vector3 gazePosition;

		private Quaternion gazeRotation;

		private bool supported;

		private float lastHardwareInput;

		public bool Enabled
		{
			get
			{
				if (supported)
				{
					return Plugin.Config.EnableEyeTracking.Value;
				}
				return false;
			}
		}

		public Ray Gaze { get; private set; }

		private void Awake()
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			Actions.Instance.EyeGazePosition.performed += OnEyeGazePosition;
			Actions.Instance.EyeGazeRotation.performed += OnEyeGazeRotation;
			Plugin.Config.EnableEyeTracking.SettingChanged += OnEyeTrackingSettingChanged;
			if (Plugin.Flags.HasFlag(Flags.EyeTrackingDebug))
			{
				debugCube = Object.Instantiate<GameObject>(AssetCollection.Cube).transform;
				((Renderer)((Component)debugCube).GetComponent<MeshRenderer>()).material.color = Color.blue;
				((Component)debugCube).GetComponent<Collider>().enabled = false;
				debugCube.position = Vector3.down * 1000f;
				((Component)debugCube).gameObject.layer = 5;
				Transform obj = debugCube;
				obj.localScale *= 2f;
			}
		}

		private void OnDestroy()
		{
			Actions.Instance.EyeGazePosition.performed -= OnEyeGazePosition;
			Actions.Instance.EyeGazeRotation.performed -= OnEyeGazeRotation;
			Plugin.Config.EnableEyeTracking.SettingChanged -= OnEyeTrackingSettingChanged;
		}

		private void OnEyeGazePosition(CallbackContext ctx)
		{
			//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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			gazePosition = ((CallbackContext)(ref ctx)).ReadValue<Vector3>();
			if (supported || !(gazePosition == Vector3.zero))
			{
				supported = true;
				lastHardwareInput = Time.realtimeSinceStartup;
			}
		}

		private void OnEyeGazeRotation(CallbackContext ctx)
		{
			//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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			gazeRotation = ((CallbackContext)(ref ctx)).ReadValue<Quaternion>();
			if (supported || !(gazeRotation == Quaternion.identity))
			{
				supported = true;
				lastHardwareInput = Time.realtimeSinceStartup;
			}
		}

		private static void OnEyeTrackingSettingChanged(object sender, EventArgs e)
		{
			if (!Plugin.Config.EnableEyeTracking.Value)
			{
				VRSession.Instance.Player.NetworkPlayer.DisableEyeTrackingRPC();
			}
		}

		private void Update()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: 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_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: 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_00b4: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			if (!Enabled)
			{
				return;
			}
			if (Time.realtimeSinceStartup - lastHardwareInput > 5f)
			{
				supported = false;
				VRSession.Instance.Player.NetworkPlayer.DisableEyeTrackingRPC();
				return;
			}
			Ray val = default(Ray);
			((Ray)(ref val))..ctor(((Component)this).transform.parent.TransformPoint(gazePosition), ((Component)this).transform.parent.TransformDirection(gazeRotation * Vector3.forward));
			RaycastHit val2 = default(RaycastHit);
			Vector3 val3 = (Physics.Raycast(val, ref val2, 10f, LayerMask.op_Implicit(SemiFunc.LayerMaskGetShouldHits())) ? ((RaycastHit)(ref val2)).point : (((Ray)(ref val)).origin + ((Ray)(ref val)).direction * 10f));
			Gaze = val;
			VRSession.Instance.Player.NetworkPlayer.UpdateEyeTrackingRPC(val3);
			if (Object.op_Implicit((Object)(object)debugCube))
			{
				debugCube.position = val3;
				debugCube.rotation = Quaternion.LookRotation(((Ray)(ref val)).direction);
			}
		}

		public static bool LookingAt(Vector3 position, float padWidth, float padHeight)
		{
			//IL_0009: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			VRSession instance = VRSession.Instance;
			if (instance == null)
			{
				return SemiFunc.OnScreen(position, padWidth, padHeight);
			}
			bool enabled = instance.Player.EyeTracking.Enabled;
			Ray val = (Ray)(enabled ? instance.Player.EyeTracking.Gaze : new Ray(((Component)instance.MainCamera).transform.position, ((Component)instance.MainCamera).transform.forward));
			float num = (enabled ? 15f : 25f) + (padWidth + padHeight) * 2.5f;
			Vector3 val2 = position - ((Ray)(ref val)).origin;
			return Vector3.Angle(((Ray)(ref val)).direction, ((Vector3)(ref val2)).normalized) <= num;
		}
	}
	public class VRInventory : MonoBehaviour
	{
		private const int MASK_INVENTORY = 536870912;

		public Transform visualsTransform;

		[SerializeField]
		protected VRInventorySlot[] slots;

		[SerializeField]
		protected Color holdColor;

		[SerializeField]
		protected Color hoverColor;

		[SerializeField]
		protected Color equippedColor;

		public VRRig rig;

		private bool holdingItem;

		private int hoveredSlot = -1;

		private void Update()
		{
			holdingItem = IsHoldingItem();
			HandleHoldItem();
			HandleSlotHover();
			HandleSlotInteract();
		}

		private void HandleHoldItem()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			visualsTransform.localScale = Vector3.Lerp(visualsTransform.localScale, Vector3.one * (float)((!holdingItem) ? 1 : 3), 8f * Time.deltaTime);
			visualsTransform.localPosition = Vector3.Lerp(visualsTransform.localPosition, (Vector3)(holdingItem ? new Vector3(0f, -0.5f, 1.2f) : Vector3.zero), 8f * Time.deltaTime);
			CollectionExtensions.Do<VRInventorySlot>((IEnumerable<VRInventorySlot>)slots, (Action<VRInventorySlot>)delegate(VRInventorySlot slot)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				((Component)slot.collider).transform.localScale = Vector3.Lerp(((Component)slot.collider).transform.localScale, Vector3.one * (float)((!holdingItem) ? 1 : 2), 8f * Time.deltaTime);
			});
			hoveredSlot = -1;
			if (!holdingItem || !GetBeamIntersect(out var hit2))
			{
				return;
			}
			for (int i = 0; i < slots.Length; i++)
			{
				if ((Object)(object)((RaycastHit)(ref hit2)).collider == (Object)(object)slots[i].collider)
				{
					hoveredSlot = i;
				}
			}
			static bool GetBeamIntersect(out RaycastHit hit)
			{
				//IL_003a: 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_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_008d: Unknown result type (might be due to invalid IL or missing references)
				PhysGrabBeam physGrabBeamComponent = PhysGrabber.instance.physGrabBeamComponent;
				Vector3[] array = (Vector3[])(object)new Vector3[physGrabBeamComponent.CurveResolution];
				bool flag = PhysGrabber.instance.overrideGrabDistance > 0f;
				physGrabBeamComponent.lineRenderer.GetPositions(array);
				for (int j = 0; j < array.Length - ((!flag) ? 1 : 3); j++)
				{
					Vector3 val = array[j];
					Vector3 val2 = array[j + 1];
					float num = Vector3.Distance(val, val2) + (float)(flag ? 1 : 0);
					if (Physics.Raycast(new Ray(val, val2 - val), ref hit, num, 536870912))
					{
						return true;
					}
				}
				hit = default(RaycastHit);
				return false;
			}
		}

		private void HandleSlotHover()
		{
			CollectionExtensions.Do<VRInventorySlot>((IEnumerable<VRInventorySlot>)slots, (Action<VRInventorySlot>)delegate(VRInventorySlot slot)
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				if (!Object.op_Implicit((Object)(object)slot.spot) || !((Behaviour)slot.spot).isActiveAndEnabled)
				{
					slot.isHovered = false;
					slot.targetColor = Color.clear;
				}
				else
				{
					slot.isHolding = holdingItem;
					slot.isHovered = slot.slotIndex == hoveredSlot;
					if (slot.slotIndex == hoveredSlot)
					{
						slot.targetColor = hoverColor;
					}
					else if (holdingItem)
					{
						slot.targetColor = holdColor;
					}
					else if (Object.op_Implicit((Object)(object)slot.heldItem))
					{
						slot.targetColor = equippedColor;
					}
					else
					{
						slot.targetColor = Color.clear;
					}
				}
			});
		}

		private void HandleSlotInteract()
		{
			if (SemiFunc.RunIsArena() || PlayerController.instance.InputDisableTimer > 0f)
			{
				return;
			}
			CollectionExtensions.Do<VRInventorySlot>((IEnumerable<VRInventorySlot>)slots, (Action<VRInventorySlot>)delegate(VRInventorySlot slot)
			{
				slot.isCollided = false;
				if (Object.op_Implicit((Object)(object)slot.heldItem) && ((Behaviour)slot.spot).isActiveAndEnabled)
				{
					slot.isCollided = Utils.Collide(slot.collider, VRSession.IsLeftHanded ? rig.leftHandCollider : rig.rightHandCollider);
					if (Actions.Instance["Grab"].WasPressedThisFrame() && slot.isCollided)
					{
						slot.spot.HandleInput();
					}
				}
			});
		}

		public void TryEquipItem(ItemEquippable item)
		{
			if (holdingItem && hoveredSlot != -1)
			{
				InventorySpot spot = slots[hoveredSlot].spot;
				if (((Behaviour)spot).isActiveAndEnabled)
				{
					spot.HandleInput();
				}
			}
		}

		public void EquipItem(ItemEquippable item)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Invalid comparison between Unknown and I4
			//IL_0026: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			VRInventorySlot vRInventorySlot = slots[item.equippedSpot.inventorySpotIndex];
			if ((int)GameDirector.instance.currentState != 2)
			{
				((Component)item).transform.localScale = Vector3.one * 0.1667f * 2f;
			}
			vRInventorySlot.heldItem = item;
			((Component)item).transform.parent = ((Component)vRInventorySlot).transform;
			item.rb.interpolation = (RigidbodyInterpolation)0;
			GameObjectExtensions.SetLayerRecursively(((Component)item).gameObject, 6);
			ItemMelee val = default(ItemMelee);
			if (((Component)item).TryGetComponent<ItemMelee>(ref val) && Object.op_Implicit((Object)(object)val.hurtCollider))
			{
				((Component)val.hurtCollider).gameObject.SetActive(false);
			}
			CollectionExtensions.Do<MeshRenderer>((IEnumerable<MeshRenderer>)((Component)item).GetComponentsInChildren<MeshRenderer>(), (Action<MeshRenderer>)delegate(MeshRenderer mesh)
			{
				((Renderer)mesh).shadowCastingMode = (ShadowCastingMode)0;
			});
		}

		public void UnequipItem(ItemEquippable item)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			slots[item.equippedSpot.inventorySpotIndex].heldItem = null;
			((Component)item).transform.localPosition = Vector3.zero;
			((Component)item).transform.localRotation = Quaternion.identity;
			Transform transform = ((Component)item).transform;
			GameObject obj = GameObject.Find("Level Generator/Items");
			transform.parent = ((obj != null) ? obj.transform : null);
			item.rb.interpolation = (RigidbodyInterpolation)1;
			GameObjectExtensions.SetLayerRecursively(((Component)item).gameObject, 16);
			((Behaviour)item).enabled = true;
			PhysGrabber.instance.OverrideGrab(item.physGrabObject, 0.25f, false);
			CollectionExtensions.Do<MeshRenderer>((IEnumerable<MeshRenderer>)((Component)item).GetComponentsInChildren<MeshRenderer>(), (Action<MeshRenderer>)delegate(MeshRenderer mesh)
			{
				((Renderer)mesh).shadowCastingMode = (ShadowCastingMode)1;
			});
		}

		public void PingSlot(int index, float amount, float frequency, float time)
		{
			slots[index].Ping(amount, frequency, time);
		}

		private static bool IsHoldingItem()
		{
			if (SemiFunc.RunIsArena() || PlayerController.instance.InputDisableTimer > 0f)
			{
				return false;
			}
			if (PhysGrabber.instance.grabbed)
			{
				PhysGrabObject grabbedPhysGrabObject = PhysGrabber.instance.grabbedPhysGrabObject;
				if (grabbedPhysGrabObject != null)
				{
					return Object.op_Implicit((Object)(object)((Component)grabbedPhysGrabObject).GetComponent<ItemEquippable>());
				}
			}
			return false;
		}
	}
	public class VRInventorySlot : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <Start>d__18 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public VRInventorySlot <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Start>d__18(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				VRInventorySlot vRInventorySlot = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					vRInventorySlot.spot = Inventory.instance.inventorySpots[vRInventorySlot.slotIndex];
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static readonly int ColorId = Shader.PropertyToID("_Color");

		private static readonly int EmissionColorId = Shader.PropertyToID("_EmissionColor");

		public int slotIndex = -1;

		public LineRenderer lineRenderer;

		public Collider collider;

		public InventorySpot spot;

		public bool isHolding;

		public bool isHovered;

		public bool isCollided;

		public Color targetColor = Color.clear;

		public ItemEquippable? heldItem;

		private float heightOffset;

		private Color currentColor = Color.clear;

		private float pingTime;

		private float pingAmount;

		private float pingFrequency;

		private float pingDuration;

		private float pingValue;

		[IteratorStateMachine(typeof(<Start>d__18))]
		private IEnumerator Start()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Start>d__18(0)
			{
				<>4__this = this
			};
		}

		private void Update()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: 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_0188: 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_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			Color val = (currentColor = Color.Lerp(currentColor, targetColor, 5f * Time.deltaTime));
			heightOffset = Mathf.Lerp(heightOffset, isHovered ? 0.02f : 0f, 5f * Time.deltaTime);
			if (pingTime < pingDuration)
			{
				val = Color.Lerp(currentColor, Color.white, Mathf.Abs(pingValue / pingAmount));
			}
			lineRenderer.widthMultiplier = Mathf.Lerp(lineRenderer.widthMultiplier, isHolding ? 0.2f : 0.1f, 5f * Time.deltaTime);
			Material material = ((Renderer)lineRenderer).material;
			material.mainTextureOffset += Vector2.right * (Time.deltaTime * (isHolding ? 2f : 0.4f));
			((Renderer)lineRenderer).material.SetColor(ColorId, new Color(val.r, val.g, val.b, val.a * 0.6f));
			((Renderer)lineRenderer).material.SetColor(EmissionColorId, val);
			((Component)this).transform.localScale = Vector3.Lerp(((Component)this).transform.localScale, Vector3.one * (isCollided ? 1.3f : 1f), 10f * Time.deltaTime);
			if ((Object)(object)heldItem != (Object)null)
			{
				((Component)heldItem).transform.localPosition = Vector3.Lerp(((Component)heldItem).transform.localPosition, Vector3.zero, 5f * Time.deltaTime);
				((Component)heldItem).transform.localRotation = Quaternion.Slerp(((Component)heldItem).transform.localRotation, Quaternion.identity, 5f * Time.deltaTime);
			}
		}

		private void LateUpdate()
		{
			//IL_0065: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: 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_012b: 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_015e: 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)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			float num = heightOffset;
			if (pingTime < pingDuration)
			{
				pingValue = CalculateSpringOffset(pingTime, pingAmount, pingFrequency, pingDuration);
				num += pingValue * 0.0025f;
				pingTime += Time.deltaTime;
			}
			((Component)this).transform.localPosition = new Vector3(((Component)this).transform.localPosition.x, pingValue * 0.0025f, ((Component)this).transform.localPosition.z);
			lineRenderer.positionCount = 4;
			lineRenderer.SetPositions((Vector3[])(object)new Vector3[4]
			{
				((Component)this).transform.TransformPoint(new Vector3(-0.045f, num, -0.07f)),
				((Component)this).transform.TransformPoint(new Vector3(0.045f, num, -0.07f)),
				((Component)this).transform.TransformPoint(new Vector3(0.045f, num, 0.07f)),
				((Component)this).transform.TransformPoint(new Vector3(-0.045f, num, 0.07f))
			});
			if ((Object)(object)spot != (Object)null)
			{
				((Component)spot.batteryVisualLogic).transform.position = ((Component)this).transform.TransformPoint(Vector3.back * 0.05f);
				((Component)spot.batteryVisualLogic).transform.rotation = ((Component)this).transform.rotation * Quaternion.Euler(90f, 0f, 0f);
			}
			if ((Object)(object)heldItem != (Object)null)
			{
				heldItem.rb.interpolation = (RigidbodyInterpolation)0;
			}
		}

		public void Ping(float amount, float frequency, float time)
		{
			pingTime = 0f;
			pingAmount = amount;
			pingFrequency = frequency;
			pingDuration = time;
		}

		private static float CalculateSpringOffset(float currentTime, float amount, float frequency, float duration)
		{
			float num = currentTime / duration;
			float num2 = frequency * (1f - num);
			return amount * Mathf.Sin(num2 * num * MathF.PI * 2f) * (1f - num);
		}
	}
	public class VRMapTool : MonoBehaviour
	{
		public static VRMapTool instance;

		private MapToolController controller;

		private DirtFinderCounter playerCounter;

		private RenderTexture displayTexture;

		private Light light;

		private Transform displaySpring;

		private StatsUI statsUI;

		private RectTransform statsRect;

		private LevelUI levelUI;

		private RectTransform levelRect;

		private bool shadowVisible = true;

		private MeshRenderer[] renderers;

		public bool leftHanded;

		public static void Create()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			MapToolController val = ((IEnumerable<MapToolController>)Object.FindObjectsOfType<MapToolController>()).FirstOrDefault((Func<MapToolController, bool>)((MapToolController t) => t.PlayerAvatar.isLocal));
			if ((Object)(object)instance != (Object)null)
			{
				return;
			}
			VRSession vRSession = VRSession.Instance;
			if (vRSession != null && val != null && val.PlayerAvatar.isLocal)
			{
				((Component)val).transform.parent.parent = vRSession.Player.MapParent;
				((Component)val).transform.parent.localPosition = Vector3.zero;
				((Component)val).transform.parent.localRotation = Quaternion.identity;
				((Component)val).gameObject.AddComponent<VRMapTool>().renderers = (from r in ((Component)val.VisualTransform).GetComponentsInChildren<MeshRenderer>()
					where (int)((Renderer)r).shadowCastingMode == 1
					select r).ToArray();
			}
		}

		private void Awake()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			instance = this;
			controller = ((Component)this).GetComponent<MapToolController>();
			playerCounter = ((Component)((Component)this).transform.parent).GetComponentInChildren<DirtFinderCounter>(true);
			displaySpring = controller.HideTransform.Find("Main Spring/Base Offset/Bob/Main Unit/Display Spring");
			Transform val = displaySpring.Find("display_1x1");
			displayTexture = (RenderTexture)((Renderer)((Component)val).GetComponent<MeshRenderer>()).material.mainTexture;
			light = ((Component)displaySpring.Find("Light")).GetComponent<Light>();
			((Component)val).transform.localPosition = Vector3.back * 0.006f;
			statsUI = StatsUI.instance;
			((SemiUI)statsUI).animateTheEntireObject = false;
			statsRect = ((Component)statsUI).GetComponent<RectTransform>();
			levelUI = LevelUI.instance;
			levelRect = ((Component)levelUI).GetComponent<RectTransform>();
		}

		private void Start()
		{
			((SemiUI)statsUI).AllChildrenSetActive(false);
			((SemiUI)levelUI).AllChildrenSetActive(false);
		}

		private void OnDestroy()
		{
			instance = null;
		}

		private void Update()
		{
			playerCounter.OnEnable();
			if (controller.Active)
			{
				if (!shadowVisible)
				{
					shadowVisible = true;
					CollectionExtensions.Do<MeshRenderer>((IEnumerable<MeshRenderer>)renderers, (Action<MeshRenderer>)delegate(MeshRenderer r)
					{
						((Renderer)r).shadowCastingMode = (ShadowCastingMode)1;
					});
				}
				light.intensity = Mathf.Lerp(light.intensity, 1f, 4f * Time.deltaTime);
				VRSession.Instance.Player.DisableGrabRotate(0.1f);
				((SemiUI)statsUI).Show();
				((SemiUI)levelUI).Show();
				return;
			}
			displayTexture.Release();
			light.intensity = Mathf.Lerp(light.intensity, 0f, 4f * Time.deltaTime);
			if (light.intensity < 0.1f && shadowVisible)
			{
				shadowVisible = false;
				CollectionExtensions.Do<MeshRenderer>((IEnumerable<MeshRenderer>)renderers, (Action<MeshRenderer>)delegate(MeshRenderer r)
				{
					((Renderer)r).shadowCastingMode = (ShadowCastingMode)0;
				});
			}
		}

		private void LateUpdate()
		{
			UpdateStatsUI();
			UpdateLevelUI();
		}

		private void UpdateStatsUI()
		{
			//IL_0018: 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_004c: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			float num = (((!(((SemiUI)statsUI).showTimer > 0f) || !(((SemiUI)statsUI).hidePositionCurrent == ((SemiUI)statsUI).showPosition)) && (!((double)((SemiUI)statsUI).hideTimer > 0.1) || !(((SemiUI)statsUI).hidePositionCurrent == ((SemiUI)statsUI).hidePosition))) ? (((((SemiUI)statsUI).showTimer > 0f) ? (1f - ((SemiUI)statsUI).animationEval) : ((SemiUI)statsUI).animationEval) * 0.25f) : 0f);
			float num2 = (0f - (leftHanded ? 0.175f : 0.275f) + num) * (float)((!leftHanded) ? 1 : (-1));
			((Transform)statsRect).rotation = displaySpring.rotation * Quaternion.Euler(90f, 0f, 0f);
			((Transform)statsRect).position = displaySpring.TransformPoint(new Vector3(num2, 0f, 0.2f));
			((Transform)statsRect).localScale = ((Component)this).transform.parent.localScale;
		}

		private void UpdateLevelUI()
		{
			//IL_0018: 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_004c: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			float num = (((!(((SemiUI)levelUI).showTimer > 0f) || !(((SemiUI)levelUI).hidePositionCurrent == ((SemiUI)levelUI).showPosition)) && (!((double)((SemiUI)levelUI).hideTimer > 0.1) || !(((SemiUI)levelUI).hidePositionCurrent == ((SemiUI)levelUI).hidePosition))) ? (((((SemiUI)levelUI).showTimer > 0f) ? (1f - ((SemiUI)levelUI).animationEval) : ((SemiUI)levelUI).animationEval) * 0.25f) : 0f);
			float num2 = (0.225f - num) * (float)((!leftHanded) ? 1 : (-1));
			((Transform)levelRect).rotation = displaySpring.rotation * Quaternion.Euler(90f, 0f, 0f);
			((Transform)levelRect).position = displaySpring.TransformPoint(new Vector3(num2, 0f, 0.23f));
			((Transform)levelRect).localScale = ((Component)this).transform.parent.localScale;
		}
	}
	public class VRPlayer : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <Start>d__35 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public VRPlayer <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Start>d__35(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				VRPlayer vRPlayer = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					vRPlayer.ResetHeight();
					vRPlayer.SyncNetworkVariables();
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private VRCameraPosition cameraPosition;

		private VRCameraAim cameraAim;

		private Transform mainCamera;

		private Transform handContainer;

		private Transform leftHand;

		private Transform rightHand;

		private PlayerController localController;

		private VRRig localRig;

		private VREyeTracking eyeTracking;

		private PlayerAvatarVisuals playerAvatarVisuals;

		private PlayerAvatarLeftArm playerLeftArm;

		private PlayerAvatarRightArm playerRightArm;

		private Transform leftHandAnchor;

		private Transform rightHandAnchor;

		private NetworkPlayer networkPlayer;

		public float disableRotateTimer;

		public bool physicalCrouch;

		private float movementRelative;

		private bool turnedLastInput;

		private Vector3 lastPosition;

		private bool wasPhysicalCrouch;

		public Transform MainHand
		{
			get
			{
				if (!VRSession.IsLeftHanded)
				{
					return localRig.rightHandTip;
				}
				return localRig.leftHandTip;
			}
		}

		public Transform SecondaryHand
		{
			get
			{
				if (!VRSession.IsLeftHanded)
				{
					return localRig.leftHandTip;
				}
				return localRig.rightHandTip;
			}
		}

		public Transform MapParent => localRig.map;

		public VRRig Rig => localRig;

		public VREyeTracking EyeTracking => eyeTracking;

		public NetworkPlayer NetworkPlayer => networkPlayer;

		private void Awake()
		{
			//IL_007d: 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_00c8: 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_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			cameraPosition = VRCameraPosition.instance;
			cameraAim = VRCameraAim.instance;
			mainCamera = ((Component)VRSession.Instance.MainCamera).transform;
			localController = PlayerController.instance;
			localController.cameraGameObject = ((Component)mainCamera).gameObject;
			localController.cameraGameObjectLocal = ((Component)mainCamera).gameObject;
			localRig = Object.Instantiate<GameObject>(AssetCollection.VRRig).GetComponent<VRRig>();
			handContainer = new GameObject("Hand Container").transform;
			((Component)handContainer).transform.SetParent(((Component)mainCamera).transform.parent, false);
			leftHand = new GameObject("Left Hand").transform;
			rightHand = new GameObject("Right Hand").transform;
			Transform transform = ((Component)leftHand).transform;
			Transform parent = (((Component)rightHand).transform.parent = handContainer);
			transform.parent = parent;
			TrackedPoseDriver obj = ((Component)leftHand).gameObject.AddComponent<TrackedPoseDriver>();
			TrackedPoseDriver val2 = ((Component)rightHand).gameObject.AddComponent<TrackedPoseDriver>();
			obj.positionAction = Actions.Instance.LeftHandPosition;
			obj.rotationAction = Actions.Instance.LeftHandRotation;
			obj.trackingStateInput = new InputActionProperty(Actions.Instance.LeftHandTrackingState);
			val2.positionAction = Actions.Instance.RightHandPosition;
			val2.rotationAction = Actions.Instance.RightHandRotation;
			val2.trackingStateInput = new InputActionProperty(Actions.Instance.RightHandTrackingState);
			localRig.head = mainCamera;
			localRig.leftArmTarget = leftHand;
			localRig.rightArmTarget = rightHand;
			eyeTracking = ((Component)mainCamera).gameObject.AddComponent<VREyeTracking>();
			playerAvatarVisuals = localController.playerAvatarScript.playerAvatarVisuals;
			playerLeftArm = ((Component)playerAvatarVisuals).GetComponent<PlayerAvatarLeftArm>();
			playerRightArm = playerAvatarVisuals.playerAvatarRightArm;
			GameObject val3 = new GameObject("Left Hand Anchor");
			val3.transform.parent = playerLeftArm.leftArmTransform;
			val3.transform.localPosition = Vector3.forward * 0.513f;
			leftHandAnchor = val3.transform;
			GameObject val4 = new GameObject("Right Hand Anchor");
			val4.transform.parent = playerRightArm.rightArmTransform.Find("ANIM ARM R SCALE");
			val4.transform.localPosition = Vector3.forward * 0.513f;
			rightHandAnchor = val4.transform;
			networkPlayer = ((Component)this).gameObject.AddComponent<NetworkPlayer>();
			networkPlayer.playerAvatar = localController.playerAvatarScript;
			Actions.Instance["ResetHeight"].performed += OnResetHeight;
		}

		private void OnDestroy()
		{
			Actions.Instance["ResetHeight"].performed -= OnResetHeight;
		}

		[IteratorStateMachine(typeof(<Start>d__35))]
		private IEnumerator Start()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Start>d__35(0)
			{
				<>4__this = this
			};
		}

		private void FixedUpdate()
		{
			HandleMovement();
			HandleCrouching();
		}

		private void Update()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			HandleTurning();
			cameraPosition.additionalOffset = -(((Component)mainCamera).transform.parent.rotation * new Vector3(mainCamera.localPosition.x, 0f, mainCamera.localPosition.z));
			if (disableRotateTimer > 0f)
			{
				disableRotateTimer -= Time.deltaTime;
			}
		}

		private void LateUpdate()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			if (!localController.playerAvatarScript.isTumbling && !localController.playerAvatarScript.localCamera.GetOverrideActive())
			{
				playerRightArm.rightArmTransform.LookAt(rightHand.position);
				playerLeftArm.leftArmTransform.LookAt(leftHand.position);
			}
			Transform val = (VRSession.IsLeftHanded ? rightHandAnchor : leftHandAnchor);
			Transform transform = ((Component)FlashlightController.Instance.meshShadows).transform;
			Transform transform2 = ((Component)FlashlightController.Instance.mesh).transform;
			transform.position = (localRig.HeadLampEnabled() ? transform2.position : val.position);
			transform.rotation = transform2.rotation;
		}

		public void DisableGrabRotate(float time)
		{
			disableRotateTimer = time;
		}

		private void ResetHeight()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			cameraPosition.original.playerOffset = new Vector3(0f, 1.5f - ((Component)mainCamera).transform.localPosition.y, 0f);
		}

		private void SyncNetworkVariables()
		{
			NetworkPlayer.UpdateVehicleHeadForwardRPC(Plugin.Config.VehicleHeadForward.Value);
			NetworkPlayer.UpdateDominantHandRPC(VRSession.IsLeftHanded);
			NetworkPlayer.UpdateHeadlampRPC(Rig.HeadLampEnabled());
		}

		private void HandleMovement()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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_0076: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0144: 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)
			if (!(((Component)mainCamera).transform.localPosition == Vector3.zero) && !(InputManager.instance.disableControlsExceptTimer > 0f) && !VRCameraPosition.instance.overridePositionActive)
			{
				if (lastPosition == Vector3.zero)
				{
					lastPosition = ((Component)mainCamera).transform.localPosition;
				}
				Vector3 localPosition = ((Component)mainCamera).transform.localPosition;
				Vector3 val = default(Vector3);
				((Vector3)(ref val))..ctor(localPosition.x - lastPosition.x, 0f, localPosition.z - lastPosition.z);
				PlayerController.instance.rb.MovePosition(((Component)PlayerController.instance.rb).transform.position + ((Component)mainCamera).transform.parent.rotation * val);
				movementRelative += ((Vector3)(ref val)).sqrMagnitude;
				if (movementRelative > 0.0003f)
				{
					PlayerController.instance.movingResetTimer = 0.1f;
					PlayerController.instance.moving = true;
				}
				movementRelative = Mathf.Lerp(movementRelative, 0f, 5f * Time.fixedDeltaTime);
				lastPosition = localPosition;
			}
		}

		private void HandleCrouching()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			float num = 1.5f - cameraPosition.original.playerOffset.y;
			float num2 = ((Component)mainCamera).transform.localPosition.y - num;
			if (num2 > 0.5f)
			{
				ResetHeight();
			}
			else if (((Component)mainCamera).transform.position.y < ((Component)PlayerAvatar.instance).transform.position.y + 0.1f)
			{
				ResetHeight();
			}
			if (num2 <= -0.6f)
			{
				physicalCrouch = true;
			}
			else if (num2 > -0.6f)
			{
				physicalCrouch = false;
			}
			if (!Plugin.Config.RoomscaleCrouch.Value)
			{
				physicalCrouch = false;
				if (num2 < -0.5f)
				{
					ResetHeight();
				}
				return;
			}
			if (physicalCrouch != wasPhysicalCrouch)
			{
				wasPhysicalCrouch = physicalCrouch;
				if (!physicalCrouch)
				{
					PlayerController.instance.toggleCrouch = false;
					CameraCrouchPosition.instance.Lerp = 0f;
				}
			}
			if (physicalCrouch)
			{
				PlayerController.instance.toggleCrouch = true;
			}
		}

		private void HandleTurning()
		{
			if (PlayerAvatar.instance.physGrabber.isRotating || PlayerController.instance.InputDisableTimer > 0f || VRCameraAim.instance.IsActive)
			{
				return;
			}
			float num = Actions.Instance["Turn"].ReadValue<float>();
			switch (Plugin.Config.TurnProvider.Value)
			{
			case Config.TurnProviderOption.Snap:
			{
				bool flag = Mathf.Abs(num) > 0.75f;
				float num2 = Plugin.Config.SnapTurnSize.Value;
				if (PlayerController.instance.overrideTimeScaleTimer > 0f)
				{
					num2 *= PlayerController.instance.overrideTimeScaleMultiplier;
				}
				if (!turnedLastInput && flag)
				{
					if (num > 0f)
					{
						cameraAim.TurnAimNow(num2);
					}
					else
					{
						cameraAim.TurnAimNow(0f - num2);
					}
				}
				turnedLastInput = flag;
				break;
			}
			case Config.TurnProviderOption.Smooth:
				if (!Plugin.Config.AnalogSmoothTurn.Value)
				{
					num = ((num != 0f) ? Math.Sign(num) : 0);
				}
				if (PlayerController.instance.overrideTimeScaleTimer > 0f)
				{
					num *= PlayerController.instance.overrideTimeScaleMultiplier;
				}
				if (num != 0f)
				{
					cameraAim.TurnAimNow(180f * Time.deltaTime * Plugin.Config.SmoothTurnSpeedModifier.Value * num);
				}
				break;
			case Config.TurnProviderOption.Disabled:
				break;
			}
		}

		private void OnResetHeight(CallbackContext ctx)
		{
			if (((CallbackContext)(ref ctx)).performed)
			{
				ResetHeight();
			}
		}
	}
	public class VRRig : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <Start>d__43 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public VRRig <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Start>d__43(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				VRRig vRRig = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					vRRig.player = VRSession.Instance.Player;
					vRRig.playerAvatar = PlayerController.instance.playerAvatarScript;
					vRRig.playerAvatarVisuals = vRRig.playerAvatar.playerAvatarVisuals;
					vRRig.playerAvatarRightArm = ((Component)vRRig.playerAvatarVisuals).GetComponentInChildren<PlayerAvatarRightArm>(true);
					GameObjectExtensions.SetLayerRecursively(((Component)vRRig.playerAvatarRightArm.grabberClawParent).gameObject, 6);
					CollectionExtensions.Do<MeshRenderer>((IEnumerable<MeshRenderer>)((Component)vRRig.playerAvatarRightArm.grabberClawParent).GetComponentsInChildren<MeshRenderer>(), (Action<MeshRenderer>)delegate(MeshRenderer mesh)
					{
						((Renderer)mesh).shadowCastingMode = (ShadowCastingMode)0;
					});
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					vRRig.flashlight = FlashlightController.Instance;
					vRRig.mapTool = Object.FindObjectsOfType<MapToolController>().First((MapToolController tool) => tool.PlayerAvatar.isLocal);
					vRRig.planeOffsetTransform.localPosition = Vector3.up * Plugin.Config.HUDPlaneOffset.Value;
					Object.Instantiate<GameObject>(AssetCollection.ExpressionWheel, ((Component)CameraUtils.Instance.MainCamera).transform.parent).GetComponent<ExpressionRadial>();
					vRRig.UpdateDominantTransforms();
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static readonly int HurtColor = Shader.PropertyToID("_ColorOverlayAmount");

		private static readonly int HurtAmount = Shader.PropertyToID("_ColorOverlayAmount");

		public MeshRenderer leftArmMesh;

		public MeshRenderer rightArmMesh;

		public Transform head;

		public Transform leftArm;

		public Transform rightArm;

		public Transform leftArmCenter;

		public Transform rightArmCenter;

		public Transform leftArmTarget;

		public Transform rightArmTarget;

		public Transform leftHandAnchor;

		public Transform rightHandAnchor;

		public Transform leftHandTip;

		public Transform rightHandTip;

		public Transform headAnchor;

		public Transform planeOffsetTransform;

		public RectTransform infoHud;

		public Transform inventory;

		public Transform map;

		public Transform headLamp;

		public Collider leftHandCollider;

		public Collider rightHandCollider;

		public Collider mapPickupCollider;

		public Collider lampTriggerCollider;

		public Collider[] shoulderMapPickupColliders;

		public VRInventory inventoryController;

		public Vector3 headOffset;

		public Vector3 mapRightPosition;

		public Vector3 mapLeftPosition;

		private bool armsDetached;

		private Transform leftArmMeshTransform;

		private Transform rightArmMeshTransform;

		private VRPlayer player;

		private PlayerAvatar playerAvatar;

		private PlayerAvatarVisuals playerAvatarVisuals;

		private PlayerAvatarRightArm playerAvatarRightArm;

		private FlashlightController flashlight;

		private MapToolController mapTool;

		private bool mapHeldLeftHand;

		private bool mapHeld;

		private bool mapHovered;

		private bool lookingAtHud;

		private bool headlampHovered;

		private bool headlampEnabled;

		private Vector3 MapPrimaryPosition
		{
			get
			{
				//IL_000f: 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)
				if (!VRSession.IsLeftHanded)
				{
					return mapRightPosition;
				}
				return mapLeftPosition;
			}
		}

		private Vector3 MapSecondaryPosition
		{
			get
			{
				//IL_000f: 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)
				if (!VRSession.IsLeftHanded)
				{
					return mapLeftPosition;
				}
				return mapRightPosition;
			}
		}

		private void Awake()
		{
			leftArmMeshTransform = ((Component)leftArmMesh).transform.parent;
			rightArmMeshTransform = ((Component)rightArmMesh).transform.parent;
			headlampEnabled = DataManager.instance.headlampEnabled;
			Plugin.Config.LeftHandDominant.SettingChanged += OnDominantHandChanged;
			Plugin.Config.DetachedArms.SettingChanged += OnDetachedArmsChanged;
			OnDetachedArmsChanged(null, null);
		}

		private void OnDestroy()
		{
			Plugin.Config.LeftHandDominant.SettingChanged -= OnDominantHandChanged;
			Plugin.Config.DetachedArms.SettingChanged -= OnDetachedArmsChanged;
		}

		[IteratorStateMachine(typeof(<Start>d__43))]
		private IEnumerator Start()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Start>d__43(0)
			{
				<>4__this = this
			};
		}

		private void LateUpdate()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: 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_00bf: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.position = head.position + headOffset;
			((Component)this).transform.rotation = Quaternion.Lerp(((Component)this).transform.rotation, Quaternion.Euler(((Component)this).transform.eulerAngles.x, head.eulerAngles.y, ((Component)this).transform.eulerAngles.z), 10f * Time.deltaTime);
			if (playerAvatar.localCamera.GetOverrideActive())
			{
				Transform transform = ((Component)this).transform;
				transform.position += Vector3.down * 3000f;
			}
			headAnchor.position = head.position;
			headAnchor.rotation = head.rotation;
			UpdateArms();
			UpdateClaw();
			MapToolLogic();
			WallClipLogic();
			LookAtHUDLogic();
			HeadLampLogic();
		}

		internal void UpdateDominantTransforms()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: 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)
			if (!playerAvatar.localCamera.GetOverrideActive())
			{
				playerAvatarRightArm.grabberClawParent.SetParent(VRSession.Instance.Player.MainHand);
				playerAvatarRightArm.grabberClawParent.localPosition = Vector3.zero;
				PhysGrabber.instance.physGrabBeamComponent.PhysGrabPointOrigin = VRSession.Instance.Player.MainHand;
				((Component)flashlight).transform.parent = (headlampEnabled ? headLamp : VRSession.Instance.Player.SecondaryHand);
				((Component)flashlight).transform.localPosition = Vector3.zero;
				((Component)flashlight).transform.localRotation = Quaternion.identity;
				((Component)lampTriggerCollider).transform.localPosition = new Vector3(VRSession.IsLeftHanded ? 0.2f : (-0.2f), ((Component)lampTriggerCollider).transform.localPosition.y, ((Component)lampTriggerCollider).transform.localPosition.z);
				player.NetworkPlayer.UpdateDominantHandRPC(Plugin.Config.LeftHandDominant.Value);
			}
		}

		private void UpdateArms()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (!playerAvatar.localCamera.GetOverrideActive())
			{
				if (armsDetached)
				{
					UpdateArmsDetached();
				}
				else
				{
					UpdateArmsAttached();
				}
				player.NetworkPlayer.UpdateRigRPC(leftHandTip.position, leftHandTip.rotation, rightHandTip.position, rightHandTip.rotation);
			}
		}

		private void UpdateArmsAttached()
		{
			//IL_000c: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: 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_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0160: Unknown result type (might be due to invalid IL or missing references)
			leftArm.localPosition = new Vector3(leftArm.localPosition.x, leftArm.localPosition.y, 0f);
			rightArm.localPosition = new Vector3(rightArm.localPosition.x, rightArm.localPosition.y, 0f);
			leftArm.LookAt(leftArmTarget.position);
			rightArm.LookAt(rightArmTarget.position);
			float z = leftHandAnchor.localPosition.z;
			float z2 = rightHandAnchor.localPosition.z;
			float num = Vector3.Distance(leftArm.position, leftArmTarget.position);
			if (num < z)
			{
				Transform obj = leftArm;
				obj.localPosition += Vector3.back * (z - num);
				leftArm.LookAt(leftArmTarget.position);
			}
			float num2 = Vector3.Distance(rightArm.position, rightArmTarget.position);
			if (num2 < z2)
			{
				Transform obj2 = rightArm;
				obj2.localPosition += Vector3.back * (z2 - num2);
				rightArm.LookAt(rightArmTarget.position);
			}
			leftArmMeshTransform.localEulerAngles = Vector3.up * 90f;
			rightArmMeshTransform.localEulerAngles = Vector3.down * 90f;
			leftArmMeshTransform.Rotate(Vector3.left, leftArmTarget.localEulerAngles.z);
			rightArmMeshTransform.Rotate(Vector3.right, rightArmTarget.localEulerAngles.z);
			leftHandTip.rotation = leftArmTarget.rotation;
			rightHandTip.rotation = rightArmTarget.rotation;
		}

		private void UpdateArmsDetached()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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_0078: 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)
			leftArm.position = leftArmTarget.position - (leftArmCenter.position - leftArm.position);
			leftArm.rotation = leftArmTarget.rotation;
			rightArm.position = rightArmTarget.position - (rightArmCenter.position - rightArm.position);
			rightArm.rotation = rightArmTarget.rotation;
		}

		private void UpdateClaw()
		{
			if (Object.op_Implicit((Object)(object)playerAvatarVisuals) && Object.op_Implicit((Object)(object)playerAvatar) && Object.op_Implicit((Object)(object)playerAvatarRightArm) && !playerAvatarVisuals.isMenuAvatar && (!((Behaviour)playerAvatar).isActiveAndEnabled || !playerAvatarRightArm.playerAvatar.playerHealth.hurtFreeze) && !playerAvatar.localCamera.GetOverrideActive())
			{
				playerAvatarRightArm.deltaTime = playerAvatarVisuals.deltaTime;
				playerAvatarRightArm.GrabberLogic();
			}
		}

		private void MapToolLogic()
		{
			//IL_0024: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)mapTool))
			{
				return;
			}
			((Component)map).transform.localPosition = Vector3.Lerp(((Component)map).transform.localPosition, PhysGrabber.instance.grabbed ? MapSecondaryPosition : MapPrimaryPosition, 8f * Time.deltaTime);
			((Component)mapTool).transform.parent.localPosition = Vector3.Lerp(((Component)mapTool).transform.parent.localPosition, Vector3.zero, 5f * Time.deltaTime);
			((Component)mapTool).transform.parent.localRotation = Quaternion.Slerp(((Component)mapTool).transform.parent.localRotation, Quaternion.identity, 5f * Time.deltaTime);
			if (!mapTool.Active && mapHeld)
			{
				mapHeld = false;
				mapHeldLeftHand = false;
				((Component)mapTool).transform.parent.parent = map;
				((Behaviour)playerAvatar.physGrabber).enabled = true;
			}
			mapHeld = mapTool.Active;
			if (playerAvatar.isDisabled || VRCameraAim.instance.IsActive || SemiFunc.MenuLevel())
			{
				mapTool.Active = false;
				return;
			}
			Collider lhs = rightHandCollider;
			Collider val = mapPickupCollider;
			Collider[] array = shoulderMapPickupColliders;
			int num = 0;
			Collider[] array2 = (Collider[])(object)new Collider[1 + array.Length];
			array2[num] = val;
			num++;
			ReadOnlySpan<Collider> readOnlySpan = new ReadOnlySpan<Collider>(array);
			readOnlySpan.CopyTo(new Span<Collider>(array2).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			bool flag = Utils.Collide(lhs, array2);
			Collider lhs2 = leftHandCollider;
			val = mapPickupCollider;
			array2 = shoulderMapPickupColliders;
			num = 0;
			array = (Collider[])(object)new Collider[1 + array2.Length];
			array[num] = val;
			num++;
			readOnlySpan = new ReadOnlySpan<Collider>(array2);
			readOnlySpan.CopyTo(new Span<Collider>(array).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			bool flag2 = Utils.Collide(lhs2, array);
			if (!mapTool.Active && !mapHovered && flag2)
			{
				mapHovered = true;
				HapticManager.Impulse(HapticManager.Hand.Left, HapticManager.Type.Impulse);
			}
			else if (!mapTool.Active && !mapHovered && flag)
			{
				mapHovered = true;
				HapticManager.Impulse(HapticManager.Hand.Right, HapticManager.Type.Impulse);
			}
			else if (mapTool.Active || (!flag2 && !flag))
			{
				mapHovered = false;
			}
			if (!mapTool.Active)
			{
				Collider lhs3 = (VRSession.IsLeftHanded ? rightHandCollider : leftHandCollider);
				val = mapPickupCollider;
				array = shoulderMapPickupColliders;
				num = 0;
				array2 = (Collider[])(object)new Collider[1 + array.Length];
				array2[num] = val;
				num++;
				readOnlySpan = new ReadOnlySpan<Collider>(array);
				readOnlySpan.CopyTo(new Span<Collider>(array2).Slice(num, readOnlySpan.Length));
				num += readOnlySpan.Length;
				if (Utils.Collide(lhs3, array2) && !PlayerController.instance.sprinting)
				{
					flashlight.hideFlashlight = !headlampEnabled;
					goto IL_0388;
				}
			}
			if (!mapTool.Active)
			{
				flashlight.hideFlashlight = false;
			}
			goto IL_0388;
			IL_0388:
			if (!mapTool.Active && Actions.Instance["MapGrabRight"].WasPressedThisFrame())
			{
				Collider lhs4 = rightHandCollider;
				val = mapPickupCollider;
				array2 = shoulderMapPickupColliders;
				num = 0;
				array = (Collider[])(object)new Collider[1 + array2.Length];
				array[num] = val;
				num++;
				readOnlySpan = new ReadOnlySpan<Collider>(array2);
				readOnlySpan.CopyTo(new Span<Collider>(array).Slice(num, readOnlySpan.Length));
				num += readOnlySpan.Length;
				if (Utils.Collide(lhs4, array) && !PlayerController.instance.sprinting && mapTool.HideLerp >= 1f)
				{
					((Component)mapTool).transform.parent.parent = rightHandTip;
					mapTool.Active = true;
					VRMapTool.instance.leftHanded = false;
					flashlight.hideFlashlight = !headlampEnabled && VRSession.IsLeftHanded;
					if (!VRSession.IsLeftHanded)
					{
						playerAvatar.physGrabber.ReleaseObject(-1, 0.1f);
						((Behaviour)playerAvatar.physGrabber).enabled = false;
					}
				}
			}
			if (!mapTool.Active && Actions.Instance["MapGrabLeft"].WasPressedThisFrame())
			{
				Collider lhs5 = leftHandCollider;
				val = mapPickupCollider;
				array = shoulderMapPickupColliders;
				num = 0;
				array2 = (Collider[])(object)new Collider[1 + array.Length];
				array2[num] = val;
				num++;
				readOnlySpan = new ReadOnlySpan<Collider>(array);
				readOnlySpan.CopyTo(new Span<Collider>(array2).Slice(num, readOnlySpan.Length));
				num += readOnlySpan.Length;
				if (Utils.Collide(lhs5, array2) && !PlayerController.instance.sprinting && mapTool.HideLerp >= 1f)
				{
					((Component)mapTool).transform.parent.parent = leftHandTip;
					mapTool.Active = true;
					VRMapTool.instance.leftHanded = true;
					mapHeldLeftHand = true;
					flashlight.hideFlashlight = !headlampEnabled && !VRSession.IsLeftHanded;
					if (VRSession.IsLeftHanded)
					{
						playerAvatar.physGrabber.ReleaseObject(-1, 0.1f);
						((Behaviour)playerAvatar.physGrabber).enabled = false;
					}
				}
			}
			if (PlayerController.instance.sprinting)
			{
				mapTool.Active = false;
			}
			if (mapTool.Active && !Actions.Instance["MapGrabRight"].IsPressed() && !mapHeldLeftHand && mapTool.HideLerp <= 0f)
			{
				mapTool.Active = false;
			}
			if (mapTool.Active && !Actions.Instance["MapGrabLeft"].IsPressed() && mapHeldLeftHand && mapTool.HideLerp <= 0f)
			{
				mapTool.Active = false;
			}
			player.NetworkPlayer.UpdateMapRPC(mapHeldLeftHand, flashlight.hideFlashlight);
		}

		private void WallClipLogic()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)CameraUtils.Instance.MainCamera).transform;
			Vector3 val = VRSession.Instance.Player.MainHand.position - transform.position;
			RaycastHit val2 = default(RaycastHit);
			if (Physics.Raycast(new Ray(transform.position, val), ref val2, Vector3.Distance(transform.position, VRSession.Instance.Player.MainHand.position), 9504257))
			{
				((Component)Crosshair.instance).gameObject.SetActive(false);
				PhysGrabber.instance.grabDisableTimer = 0.1f;
			}
			else
			{
				((Component)Crosshair.instance).gameObject.SetActive(true);
			}
		}

		private void LookAtHUDLogic()
		{
			//IL_0006: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			float x = head.localEulerAngles.x;
			if (x < 180f && x > 30f && !lookingAtHud)
			{
				lookingAtHud = true;
			}
			else
			{
				x = head.localEulerAngles.x;
				bool flag = ((x < 20f || x > 180f) ? true : false);
				if (flag && lookingAtHud)
				{
					lookingAtHud = false;
				}
			}
			((Component)planeOffsetTransform).transform.localPosition = Vector3.Lerp(((Component)planeOffsetTransform).transform.localPosition, Vector3.up * (lookingAtHud ? Plugin.Config.HUDGazePlaneOffset.Value : Plugin.Config.HUDPlaneOffset.Value), 8f * Time.deltaTime);
		}

		private void HeadLampLogic()
		{
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)RunManager.instance.levelCurrent == (Object)(object)RunManager.instance.levelLobby) && (!RunManager.instance.levelIsShop || EnvironmentDirector.Instance.AmbientLightOverrideShopFlashlight))
			{
				bool flag = Utils.Collide(VRSession.IsLeftHanded ? rightHandCollider : leftHandCollider, lampTriggerCollider);
				if (flag && !headlampHovered)
				{
					HapticManager.Impulse(HapticManager.Hand.Secondary, HapticManager.Type.Impulse);
				}
				if (flag && Actions.Instance[VRSession.IsLeftHanded ? "MapGrabRight" : "MapGrabLeft"].WasPressedThisFrame())
				{
					((Component)flashlight).transform.SetParent((!headlampEnabled) ? headLamp : (VRSession.IsLeftHanded ? rightHandTip : leftHandTip), false);
					flashlight.lightOnAudio.Play(((Component)flashlight).transform.position, 1f, 1f, 1f, 1f);
					headlampEnabled = !headlampEnabled;
					DataManager.instance.headlampEnabled = headlampEnabled;
					player.NetworkPlayer.UpdateHeadlampRPC(headlampEnabled);
				}
				headlampHovered = flag;
			}
		}

		public bool HeadLampEnabled()
		{
			return headlampEnabled;
		}

		private void DetachArms()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: 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)
			armsDetached = true;
			Transform obj = leftArm;
			Vector3 localScale = (rightArm.localScale = Vector3.one * 0.3f);
			obj.localScale = localScale;
			Transform transform = ((Component)leftHandCollider).transform;
			localScale = (((Component)rightHandCollider).transform.localScale = Vector3.one * 3f);
			transform.localScale = localScale;
			leftHandTip.localRotation = Quaternion.identity;
			rightHandTip.localRotation = Quaternion.identity;
		}

		private void AttachArms()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			armsDetached = false;
			Transform obj = leftArm;
			Vector3 localScale = (rightArm.localScale = Vector3.one);
			obj.localScale = localScale;
			Transform transform = ((Component)leftHandCollider).transform;
			localScale = (((Component)rightHandCollider).transform.localScale = Vector3.one);
			transform.localScale = localScale;
			Transform obj2 = leftArm;
			localScale = (rightArm.localPosition = Vector3.zero);
			obj2.localPosition = localScale;
		}

		public void SetVisible(bool visible)
		{
			((Component)leftArmMeshTransform).gameObject.SetActive(visible);
			((Component)rightArmMeshTransform).gameObject.SetActive(visible);
			((Component)infoHud).gameObject.SetActive(visible);
			((Component)map).gameObject.SetActive(visible);
			((Component)inventory).gameObject.SetActive(visible);
		}

		public void SetLeftArmColor(int nameId, Color color)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			((Renderer)leftArmMesh).material.SetColor(nameId, color);
		}

		public void SetRightArmColor(int nameId, Color color)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			((Renderer)rightArmMesh).material.SetColor(nameId, color);
		}

		public void SetHurtColor(Color color)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			((Renderer)leftArmMesh).material.SetColor(HurtColor, color);
			((Renderer)rightArmMesh).material.SetColor(HurtColor, color);
		}

		public void SetHurtAmount(float amount)
		{
			((Renderer)leftArmMesh).material.SetFloat(HurtAmount, amount);
			((Renderer)rightArmMesh).material.SetFloat(HurtAmount, amount);
		}

		private void OnDominantHandChanged(object sender, EventArgs args)
		{
			UpdateDominantTransforms();
		}

		private void OnDetachedArmsChanged(object sender, EventArgs args)
		{
			if (Plugin.Config.DetachedArms.Value)
			{
				DetachArms();
			}
			else
			{
				AttachArms();
			}
		}
	}
}
namespace RepoXR.Player.Camera
{
	public class VRCameraAim : MonoBehaviour
	{
		public static VRCameraAim instance;

		private CameraAim cameraAim;

		private Transform mainCamera;

		public Quaternion rotationXZ = Quaternion.identity;

		public Quaternion rotationY = Quaternion.identity;

		private bool aimTargetActive;

		private GameObject? aimTargetObject;

		private Vector3 aimTargetPosition;

		private float aimTargetTimer;

		private float aimTargetSpeed;

		private int aimTargetPriority = 999;

		private bool aimTargetLowImpact;

		private float aimTargetLerp;

		private GameObject? aimTargetSoftObject;

		private Vector3 aimTargetSoftPosition;

		private float aimTargetSoftTimer;

		private float aimTargetSoftStrength;

		private float aimTargetSoftStrengthNoAim;

		private int aimTargetSoftPriority = 999;

		private bool aimTargetSoftLowImpact;

		private float aimTargetSoftStrengthCurrent;

		private Quaternion lastCameraRotation;

		private float playerAimingTimer;

		private bool setInitialAim;

		public bool IsActive => aimTargetActive;

		private void Awake()
		{
			instance = this;
			cameraAim = ((Component)this).GetComponent<CameraAim>();
			mainCamera = ((Component)((Component)this).GetComponentInChildren<Camera>()).transform;
		}

		private void Update()
		{
			//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_0024: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			if (lastCameraRotation == Quaternion.identity)
			{
				lastCameraRotation = mainCamera.localRotation;
			}
			if (Quaternion.Angle(lastCameraRotation, mainCamera.localRotation) > 1f)
			{
				playerAimingTimer = 0.1f;
			}
			lastCameraRotation = mainCamera.localRotation;
			if (playerAimingTimer > 0f)
			{
				playerAimingTimer -= Time.deltaTime;
			}
			if (aimTargetTimer > 0f)
			{
				aimTargetTimer -= Time.deltaTime;
				aimTargetLerp += Time.deltaTime * aimTargetSpeed;
				aimTargetLerp = Mathf.Clamp01(aimTargetLerp);
			}
			else if (aimTargetLerp > 0f)
			{
				cameraAim.SetPlayerAim(mainCamera.rotation, false);
				aimTargetLerp = 0f;
				aimTargetPriority = 999;
				aimTargetActive = false;
			}
			Quaternion val;
			Quaternion val2;
			(val, val2) = GetLookRotation(aimTargetPosition);
			if (aimTargetLowImpact)
			{
				val2 = Quaternion.identity;
			}
			rotationXZ = Quaternion.LerpUnclamped(rotationXZ, val2, cameraAim.AimTargetCurve.Evaluate(aimTargetLerp));
			rotationY = Quaternion.LerpUnclamped(rotationY, val, cameraAim.AimTargetCurve.Evaluate(aimTargetLerp));
			if (aimTargetSoftTimer > 0f && aimTargetTimer <= 0f)
			{
				float num = ((playerAimingTimer <= 0f) ? aimTargetSoftStrengthNoAim : aimTargetSoftStrength);
				aimTargetSoftStrengthCurrent = Mathf.Lerp(aimTargetSoftStrengthCurrent, num, 10f * Time.deltaTime);
				(val, val2) = GetLookRotation(aimTargetSoftPosition);
				if (aimTargetSoftLowImpact)
				{
					val2 = Quaternion.identity;
				}
				rotationXZ = Quaternion.Lerp(rotationXZ, val2, aimTargetSoftStrengthCurrent * Time.deltaTime);
				rotationY = Quaternion.Lerp(rotationY, val, aimTargetSoftStrengthCurrent * Time.deltaTime);
				aimTargetSoftTimer -= Time.deltaTime;
				if (aimTargetSoftTimer <= 0f)
				{
					aimTargetSoftObject = null;
					aimTargetSoftPriority = 999;
				}
			}
			if (!aimTargetActive && aimTargetSoftTimer <= 0f)
			{
				rotationXZ = Quaternion.Lerp(rotationXZ, Quaternion.identity, 5f * Time.deltaTime);
			}
			if (Object.op_Implicit((Object)(object)SpectateCamera.instance) && SpectateCamera.instance.CheckState((State)0))
			{
				((Component)this).transform.localRotation = Quaternion.identity;
			}
			else
			{
				((Component)this).transform.localRotation = Quaternion.Lerp(((Component)this).transform.localRotation, rotationY, 33f * Time.deltaTime);
			}
			cameraAim.SetPlayerAim(mainCamera.rotation, false);
		}

		private (Quaternion, Quaternion) GetLookRotation(Vector3 position)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			Quaternion val = Quaternion.LookRotation(position - mainCamera.position, Vector3.up) * Quaternion.Inverse(TrackingInput.Instance.HeadTransform.rotation);
			Vector3 val2 = val * Vector3.forward;
			Vector3 val3 = new Vector3(val2.x, 0f, val2.z);
			Quaternion val4 = Quaternion.LookRotation(((Vector3)(ref val3)).normalized, Vector3.up);
			Quaternion item = Quaternion.Inverse(val4) * val;
			return (val4, item);
		}

		public void TurnAimNow(float degrees)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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)
			Quaternion localRotation = Quaternion.Euler(((Quaternion)(ref rotationY)).eulerAngles + Vector3.up * degrees);
			((Component)this).transform.localRotation = localRotation;
			rotationY = localRotation;
		}

		public void SetAimNow(float degrees)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			Quaternion localRotation = Quaternion.Euler(0f, degrees, 0f);
			((Component)this).transform.localRotation = localRotation;
			rotationY = localRotation;
		}

		public void SetPlayerAim(float yRot, bool forceInitial = false)
		{
			//IL_0042: 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)
			if (Object.op_Implicit((Object)(object)CameraNoPlayerTarget.instance) && (!setInitialAim || forceInitial))
			{
				yRot = ((Component)CameraNoPlayerTarget.instance).transform.eulerAngles.y;
				setInitialAim = true;
			}
			SetAimNow(yRot - TrackingInput.Instance.HeadTransform.localEulerAngles.y);
		}

		public void SetAimTarget(Vector3 position, float time, float speed, GameObject obj, int priority, bool lowImpact = false)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (priority <= aimTargetPriority && (!((Object)(object)obj != (Object)(object)aimTargetObject) || aimTargetLerp == 0f))
			{
				aimTargetActive = true;
				aimTargetObject = obj;
				aimTargetPosition = position;
				aimTargetTimer = time;
				aimTargetSpeed = speed;
				aimTargetPriority = priority;
				aimTargetLowImpact = lowImpact;
			}
		}

		public void SetAimTargetSoft(Vector3 position, float time, float strength, float strengthNoAim, GameObject obj, int priority, bool lowImpact = false)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (priority <= aimTargetSoftPriority && (!Object.op_Implicit((Object)(object)aimTargetSoftObject) || !((Object)(object)obj != (Object)(object)aimTargetSoftObject)))
			{
				if ((Object)(object)obj != (Object)(object)aimTargetSoftObject)
				{
					playerAimingTimer = 0f;
				}
				aimTargetSoftPosition = position;
				aimTargetSoftTimer = time;
				aimTargetSoftStrength = strength;
				aimTargetSoftStrengthNoAim = strengthNoAim;
				aimTargetSoftObject = obj;
				aimTargetSoftPriority = priority;
				aimTargetSoftLowImpact = lowImpact;
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class CameraAimPatches
	{
		[HarmonyPatch(typeof(CameraAim), "Awake")]
		[HarmonyPostfix]
		private static void OnCameraAimAwake(CameraAim __instance)
		{
			((Component)__instance).gameObject.AddComponent<VRCameraAim>();
		}

		[HarmonyPatch(typeof(CameraAim), "SetPlayerAim")]
		[HarmonyPostfix]
		private static void OnCameraAimSpawn(ref Quaternion _rotation, bool _setRotation)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (_setRotation)
			{
				VRCameraAim.instance.SetPlayerAim(((Quaternion)(ref _rotation)).eulerAngles.y);
			}
		}

		[HarmonyPatch(typeof(CameraAim), "Update")]
		[HarmonyPrefix]
		private static bool DisableCameraAim(CameraAim __instance)
		{
			return false;
		}

		[HarmonyPatch(typeof(CameraAim), "OverridePlayerAimDisable")]
		[HarmonyPrefix]
		private static bool DisableAimDisableOverride()
		{
			return false;
		}
	}
	public class VRCameraPosition : MonoBehaviour
	{
		public static VRCameraPosition instance;

		public CameraPosition original;

		public Vector3 additionalOffset;

		private Vector3 currentPosition;

		private Transform mainCamera;

		internal bool overridePositionActive;

		private float overridePositionTimer;

		private Vector3 overridePositionTarget;

		private void Awake()
		{
			instance = this;
			original = ((Component)this).GetComponent<CameraPosition>();
			mainCamera = ((Component)Camera.main).transform;
		}

		private void Update()
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: 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_010f: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			float num = original.positionSmooth;
			if (original.tumbleSetTimer > 0f)
			{
				num *= 0.5f;
				CameraPosition obj = original;
				obj.tumbleSetTimer -= Time.deltaTime;
			}
			if (overridePositionTimer > 0f)
			{
				overridePositionTimer -= Time.deltaTime;
				MoveCameraToPosition(overridePositionTarget);
				return;
			}
			Vector3 val = original.playerTransform.localPosition + original.playerOffset;
			if (SemiFunc.MenuLevel() && Object.op_Implicit((Object)(object)CameraNoPlayerTarget.instance))
			{
				val = ((Component)CameraNoPlayerTarget.instance).transform.position;
			}
			currentPosition = Vector3.Slerp(currentPosition, val, num * Time.deltaTime);
			if (overridePositionActive)
			{
				PositionOverrideToggled(val, state: false);
			}
			((Component)this).transform.localPosition = currentPosition + additionalOffset;
			((Component)this).transform.localRotation = Quaternion.Slerp(((Component)this).transform.localRotation, Quaternion.identity, num * Time.deltaTime);
			if (SemiFunc.MenuLevel())
			{
				((Component)this).transform.localPosition = val;
			}
		}

		public void OverridePosition(Vector3 pos, float time = 0.1f)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			if (time <= 0f)
			{
				overridePositionTimer = time;
				PositionOverrideToggled(original.playerTransform.position + original.playerOffset, state: false);
				return;
			}
			if (!overridePositionActive)
			{
				PositionOverrideToggled(pos, state: true);
			}
			if (Vector3.Distance(pos, ((Component)this).transform.position) > 5f)
			{
				PlayerController.instance.playerAvatarScript.localCamera.Teleported();
				AudioManager.instance.RestartAudioLoopDistances();
				LevelGenerator.Instance.RestartParticleDistances();
			}
			overridePositionTarget = pos;
			overridePositionTimer = time;
			overridePositionActive = true;
		}

		private void PositionOverrideToggled(Vector3 pos, bool state)
		{
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: 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)
			if (state)
			{
				SemiFunc.LightManagerSetCullTargetTransform(((Component)this).transform);
				PhysGrabber val = PlayerAvatar.instance?.physGrabber;
				if (val != null)
				{
					PlayerAvatarVisuals playerAvatarVisuals = PlayerAvatar.instance.playerAvatarVisuals;
					playerAvatarVisuals.playerAvatarRightArm.grabberClawParent.SetParent(playerAvatarVisuals.playerAvatarRightArm.grabberTransform);
					playerAvatarVisuals.playerAvatarRightArm.grabberClawParent.localPosition = Vector3.zero;
					val.physGrabPointPlane.SetParent(PlayerAvatar.instance.playerAvatarVisuals.playerAvatarRightArm.grabberTransformTarget, true);
					val.physGrabPointPlane.localPosition = Vector3.forward * val.physGrabPointPlane.localPosition.z;
					val.physGrabPointPlane.localRotation = Quaternion.identity;
					PhysGrabBeam physGrabBeamComponent = val.physGrabBeamComponent;
					if (physGrabBeamComponent != null)
					{
						physGrabBeamComponent.PhysGrabPointOrigin = val.physGrabBeamComponent.PhysGrabPointOriginClient;
					}
				}
				FlashlightController val2 = PlayerAvatar.instance?.flashlightController;
				if (val2 != null)
				{
					((Behaviour)val2.toolBackAway).enabled = false;
					int layer = LayerMask.NameToLayer("Triggers");
					Transform[] componentsInChildren = ((Component)val2).GetComponentsInChildren<Transform>();
					foreach (Transform val3 in componentsInChildren)
					{
						if ((Object)(object)((Component)val3).gameObject != (Object)(object)((Component)val2.meshShadows).gameObject)
						{
							((Component)val3).gameObject.layer = layer;
						}
					}
				}
				MoveCameraToPosition(pos);
				return;
			}
			PlayerAvatar val4 = PlayerAvatar.instance;
			if (val4 != null)
			{
				SemiFunc.LightManagerSetCullTargetTransform(((Component)val4).transform);
			}
			if (Vector3.Distance(pos, ((Component)this).transform.position) > 5f)
			{
				PlayerController.instance.playerAvatarScript.localCamera.Teleported();
				AudioManager.instance.RestartAudioLoopDistances();
				LevelGenerator.Instance.RestartParticleDistances();
			}
			overridePositionActive = false;
			PhysGrabber val5 = PlayerAvatar.instance?.physGrabber;
			if (val5 != null)
			{
				val5.physGrabPointPlane.SetParent(((Component)CameraAim.Instance).transform, true);
				val5.physGrabPointPlane.localPosition = Vector3.forward * val5.physGrabPointPlane.localPosition.z;
				val5.physGrabPointPlane.localRotation = Quaternion.identity;
			}
			FlashlightController val6 = PlayerAvatar.instance?.flashlightController;
			if (val6 != null)
			{
				((Behaviour)val6.toolBackAway).enabled = false;
				int layer2 = LayerMask.NameToLayer("TopLayerOnly");
				Transform[] componentsInChildren = ((Component)val6).GetComponentsInChildren<Transform>();
				foreach (Transform val7 in componentsInChildren)
				{
					if ((Object)(object)((Component)val7).gameObject != (Object)(object)((Component)val6.meshShadows).gameObject)
					{
						((Component)val7).gameObject.layer = layer2;
					}
				}
			}
			VRSession.Instance.Player.Rig.UpdateDominantTransforms();
		}

		private void MoveCameraToPosition(Vector3 pos)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			Matrix4x4 localToWorldMatrix = mainCamera.localToWorldMatrix;
			Matrix4x4 localToWorldMatrix2 = ((Component)this).transform.localToWorldMatrix;
			Matrix4x4 val = ((Matrix4x4)(ref localToWorldMatrix2)).inverse * localToWorldMatrix;
			Matrix4x4 val2 = Matrix4x4.TRS(pos, mainCamera.rotation, mainCamera.lossyScale) * ((Matrix4x4)(ref val)).inverse;
			((Component)this).transform.SetPositionAndRotation(Vector4.op_Implicit(((Matrix4x4)(ref val2)).GetColumn(3)), ((Matrix4x4)(ref val2)).rotation);
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class CameraPositionPatches
	{
		[HarmonyPatch(typeof(CameraPosition), "Awake")]
		[HarmonyPostfix]
		private static void OnCreateCameraPosition(CameraPosition __instance)
		{
			((Component)__instance).gameObject.AddComponent<VRCameraPosition>();
		}

		[HarmonyPatch(typeof(CameraPosition), "OverridePosition")]
		[HarmonyPrefix]
		private static bool OnOverrideCameraPosition(CameraPosition __instance, Vector3 _position, float _time)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((Component)__instance).GetComponent<VRCameraPosition>().OverridePosition(_position, _time);
			return false;
		}

		[HarmonyPatch(typeof(CameraPosition), "Update")]
		[HarmonyPrefix]
		private static bool DisableCameraPosition()
		{
			return false;
		}
	}
	public class VRCameraTracker : TrackedPoseDriver
	{
		public override void Awake()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			((TrackedPoseDriver)this).Awake();
			((TrackedPoseDriver)this).positionAction = Actions.Instance.HeadPosition;
			((TrackedPoseDriver)this).rotationAction = Actions.Instance.HeadRotation;
			((TrackedPoseDriver)this).trackingStateInput = new InputActionProperty(Actions.Instance.HeadTrackingState);
		}

		public override void SetLocalTransform(Vector3 newPosition, Quaternion newRotation)
		{
			//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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Quaternion val = newRotation;
			VRCameraAim instance = VRCameraAim.instance;
			if (instance != null)
			{
				val = instance.rotationXZ * val;
			}
			((TrackedPoseDriver)this).SetLocalTransform(newPosition, val);
		}
	}
	public class VRCameraZoom : MonoBehaviour
	{
		public static VRCameraZoom instance;

		private CameraZoom cameraZoom;

		private CameraPosition cameraPosition;

		private Transform? zoomTarget;

		private Vector3 targetPosition;

		private float zoomPadding;

		private float zoomTimer;

		private float zoomSpeedIn;

		private float zoomSpeedOut;

		private int zoomPriority = 999;

		private bool zoomActive;

		private float zoomLerp;

		private float zoomCurrent;

		private float zoomPrev;

		private float zoomNew;

		private void Awake()
		{
			instance = this;
			cameraZoom = ((Component)this).GetComponentInChildren<CameraZoom>();
			cameraPosition = ((Component)this).GetComponentInChildren<CameraPosition>();
		}

		private void Update()
		{
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)SpectateCamera.instance) || (SemiFunc.MenuLevel() && Object.op_Implicit((Object)(object)CameraNoPlayerTarget.instance)) || !LevelGenerator.Instance.Generated || PlayerController.instance.playerAvatarScript.isDisabled)
			{
				return;
			}
			if (zoomTimer > 0f)
			{
				zoomTimer -= Time.deltaTime;
				zoomLerp += Time.deltaTime * zoomSpeedIn;
			}
			else if (zoomTimer <= 0f)
			{
				if (zoomActive)
				{
					zoomActive = false;
					zoomTarget = null;
					zoomPriority = 999;
					zoomLerp = 0f;
					zoomPrev = zoomCurrent;
					zoomNew = 0f;
				}
				else if (zoomLerp >= 1f)
				{
					AudioManager.instance.AudioListener.TargetPositionTransform = ((Component)CameraUtils.Instance.MainCamera).transform;
				}
				zoomLerp += Time.deltaTime * zoomSpeedOut;
			}
			zoomLerp = Mathf.Clamp01(zoomLerp);
			zoomCurrent = Mathf.LerpUnclamped(zoomPrev, zoomNew, cameraZoom.OverrideZoomCurve.Evaluate(zoomLerp));
			((Component)this).transform.localPosition = Vector3.LerpUnclamped(Vector3.zero, targetPosition, zoomCurrent);
		}

		private Vector3 GetTargetVector(Vector3 position)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)CameraUtils.Instance.MainCamera).transform;
			Vector3 val = ((Component)cameraPosition).transform.localPosition + transform.localPosition;
			Vector3 val2 = position - val;
			Vector3 normalized = ((Vector3)(ref val2)).normalized;
			if (zoomPadding < 0f)
			{
				return val - normalized * zoomPadding - ((Component)cameraPosition).transform.localPosition - transform.localPosition;
			}
			return position - normalized * zoomPadding - ((Component)cameraPosition).transform.localPosition - transform.localPosition;
		}

		public void SetZoomTarget(float zoom, float time, float speedIn, float speedOut, Transform target, int priority)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if (priority <= zoomPriority)
			{
				if ((Object)(object)target != (Object)(object)zoomTarget)
				{
					zoomLerp = 0f;
					zoomPrev = zoomCurrent;
				}
				zoomNew = 1f;
				zoomPadding = zoom;
				zoomTarget = target;
				zoomTimer = time;
				zoomSpeedIn = speedIn;
				zoomSpeedOut = speedOut;
				zoomPriority = priority;
				zoomActive = true;
				targetPosition = GetTargetVector(target.position);
				AudioManager.instance.AudioListener.TargetPositionTransform = ((Component)PlayerAvatar.instance.RoomVolumeCheck).transform;
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class CameraZoomPatches
	{
		[HarmonyPatch(typeof(CameraZoom), "Awake")]
		[HarmonyPostfix]
		private static void OnCameraZoomCreated(CameraZoom __instance)
		{
			if (!(((Object)__instance).name != "Camera Controller"))
			{
				((Behaviour)__instance).enabled = false;
				((Component)__instance).gameObject.AddComponent<VRCameraZoom>();
			}
		}
	}
	[DefaultExecutionOrder(100)]
	public class VRCustomCamera : MonoBehaviour
	{
		public static VRCustomCamera instance;

		private RenderTexture targetTexture;

		[SerializeField]
		protected Camera mainCamera;

		[SerializeField]
		protected Camera topCamera;

		[SerializeField]
		protected Camera uiCamera;

		[SerializeField]
		protected Image overlayImage;

		private Transform gameplayCamera;

		private int lastWidth;

		private int lastHeight;

		private float frameTimer;

		private void Awake()
		{
			//IL_005a: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			instance = this;
			float value = Plugin.Config.CustomCameraFOV.Value;
			mainCamera.fieldOfView = value;
			topCamera.fieldOfView = value;
			uiCamera.fieldOfView = value;
			gameplayCamera = ((Component)Camera.main).transform;
			((Component)this).transform.localPosition = TrackingInput.Instance.HeadTransform.localPosition;
			((Component)this).transform.localRotation = TrackingInput.Instance.HeadTransform.localRotation;
			Plugin.Config.CustomCameraFOV.SettingChanged += OnFOVChanged;
			Application.onBeforeRender += new UnityAction(OnBeforeRender);
			UpdateRenderTexture();
		}

		private void OnDestroy()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			instance = null;
			Plugin.Config.CustomCameraFOV.SettingChanged -= OnFOVChanged;
			Application.onBeforeRender -= new UnityAction(OnBeforeRender);
		}

		private void OnBeforeRender()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.localPosition = gameplayCamera.localPosition;
		}

		private void OnFOVChanged(object sender, EventArgs e)
		{
			float value = Plugin.Config.CustomCameraFOV.Value;
			mainCamera.fieldOfView = value;
			topCamera.fieldOfView = value;
			uiCamera.fieldOfView = value;
		}

		private void Update()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			float value = Plugin.Config.CustomCameraSmoothing.Value;
			float num = ((value == 0f) ? (1f / Time.deltaTime) : Mathf.Lerp(15f, 3f, value));
			((Component)this).transform.localPosition = gameplayCamera.localPosition;
			((Component)this).transform.localRotation = Quaternion.Slerp(((Component)this).transform.localRotation, gameplayCamera.localRotation, num * Time.deltaTime);
			mainCamera.backgroundColor = RenderSettings.fogColor;
			RenderSettings.fogDensity = ((SemiFunc.RunIsRecording() || SemiFunc.MenuLevel() || SemiFunc.RunIsShop() || SemiFunc.RunIsLobby() || SemiFunc.RunIsArena()) ? 0.015f : 0.15f);
		}

		private void LateUpdate()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.localPosition = gameplayCamera.localPosition;
			((Graphic)overlayImage).color = ((Graphic)FadeOverlay.Instance.Image).color;
			if (lastWidth != Screen.width || lastHeight != Screen.height)
			{
				UpdateRenderTexture();
			}
			frameTimer += Time.unscaledDeltaTime;
			float num = 1f / Plugin.Config.CustomCameraFramerate.Value;
			if (!(frameTimer < num))
			{
				frameTimer -= num;
				mainCamera.Render();
				topCamera.Render();
				uiCamera.Render();
			}
		}

		private void UpdateRenderTexture()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			lastWidth = Screen.width;
			lastHeight = Screen.height;
			if ((Object)(object)targetTexture != (Object)null)
			{
				targetTexture.Release();
			}
			targetTexture = new RenderTexture(lastWidth, lastHeight, (GraphicsFormat)8, (GraphicsFormat)94)
			{
				name = "Custom Camera RT",
				antiAliasing = 1,
				useMipMap = false,
				autoGenerateMips = false
			};
			mainCamera.targetTexture = targetTexture;
			topCamera.targetTexture = targetTexture;
			uiCamera.targetTexture = targetTexture;
		}

		private void OnRenderImage(RenderTexture source, RenderTexture destination)
		{
			if ((Object)(object)targetTexture != (Object)null)
			{
				Graphics.Blit((Texture)(object)targetTexture, destination);
			}
			else
			{
				Graphics.Blit((Texture)(object)Texture2D.blackTexture, destination);
			}
		}
	}
	public class CustomTumbleUI : TumbleUI
	{
		public static CustomTumbleUI? instance;

		private void Awake()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			instance = this;
			base.canvasGroup = ((Component)this).GetComponent<CanvasGroup>();
			base.canExitSound = new Sound
			{
				Sounds = Array.Empty<AudioClip>()
			};
		}

		private void OnDestroy()
		{
			instance = null;
		}
	}
}
namespace RepoXR.Patches
{
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class CameraEffectsPatches
	{
		[HarmonyPatch(typeof(CameraShake), "Shake")]
		[HarmonyPrefix]
		private static bool DisableShakeMenu()
		{
			return !SemiFunc.MenuLevel();
		}

		[HarmonyPatch(typeof(CameraNoise), "Awake")]
		[HarmonyPostfix]
		private static void DisableCameraNoise(CameraNoise __instance)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			((Behaviour)__instance.AnimNoise).enabled = false;
			((Component)__instance).transform.localPosition = Vector3.zero;
			((Component)__instance).transform.localRotation = Quaternion.identity;
		}

		[HarmonyPatch(typeof(CameraCrouchNoise), "Start")]
		[HarmonyPostfix]
		private static void DisableCameraCrouchNoise(CameraCrouchNoise __instance)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			((Behaviour)__instance).enabled = false;
			((Component)__instance).transform.localPosition = Vector3.zero;
			((Component)__instance).transform.localRotation = Quaternion.identity;
		}

		[HarmonyPatch(typeof(CameraBob), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ReduceCameraBob(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(GameplayManager), "cameraAnimation"), (string)null)
			}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher matcher)
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Expected O, but got Unknown
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Expected O, but got Unknown
				matcher.Advance(1).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldc_R4, (object)0.25f),
					new CodeInstruction(OpCodes.Mul, (object)null)
				});
			}, (Action<string>)null).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(CameraJump), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ReduceCameraJump(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(GameplayManager), "cameraAnimation"), (string)null)
			}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher matcher)
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Expected O, but got Unknown
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Expected O, but got Unknown
				matcher.Advance(1).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldc_R4, (object)0.25f),
					new CodeInstruction(OpCodes.Mul, (object)null)
				});
			}, (Action<string>)null).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(CameraShake), "ShakeMultiplier")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ReduceCameraShake(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(GameplayManager), "cameraShake"), (string)null)
			}).Advance(1).Insert((CodeInstruction[])(object)new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Ldc_R4, (object)0.25f),
				new CodeInstruction(OpCodes.Mul, (object)null)
			})
				.InstructionEnumeration();
		}

		[HarmonyPatch(typeof(CameraTilt), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ReduceRotationTilt(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Stfld, (object)AccessTools.Field(typeof(CameraTilt), "tiltZresult"), (string)null)
			}).Advance(-10).Insert((CodeInstruction[])(object)new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Ldc_R4, (object)0.25f),
				new CodeInstruction(OpCodes.Mul, (object)null)
			})
				.InstructionEnumeration();
		}

		[HarmonyPatch(typeof(CameraGlitch), "PlayLong")]
		[HarmonyPostfix]
		private static void CameraGlitchLongFeedback()
		{
			HapticManager.Impulse(HapticManager.Hand.Both, HapticManager.Type.Impulse, 0.2f, 0.3f);
		}

		[HarmonyPatch(typeof(CameraGlitch), "PlayShort")]
		[HarmonyPostfix]
		private static void CameraGlitchShortFeedback()
		{
			HapticManager.Impulse(HapticManager.Hand.Both, HapticManager.Type.Impulse, 0.2f);
		}

		[HarmonyPatch(typeof(CameraGlitch), "PlayTiny")]
		[HarmonyPostfix]
		private static void CameraGlitchTinyFeedback()
		{
			HapticManager.Impulse(HapticManager.Hand.Both, HapticManager.Type.Impulse, 0.1f, 0.05f);
		}

		[HarmonyPatch(typeof(CameraGlitch), "PlayLongHeal")]
		[HarmonyPostfix]
		private static void CameraGlitchLongHealFeedback()
		{
			HapticManager.Impulse(HapticManager.Hand.Both, HapticManager.Type.Impulse, 0.25f, 0.2f);
		}

		[HarmonyPatch(typeof(CameraGlitch), "PlayShortHeal")]
		[HarmonyPostfix]
		private static void CameraGlitchShortHealFeedback()
		{
			HapticManager.Impulse(HapticManager.Hand.Both, HapticManager.Type.Impulse, 0.15f, 0.2f);
		}

		[HarmonyPatch(typeof(CameraGlitch), "PlayUpgrade")]
		[HarmonyPostfix]
		private static void CameraGlitchUpgradeFeedback()
		{
			HapticManager.Impulse(HapticManager.Hand.Both, HapticManager.Type.Impulse, 0.2f, 0.5f);
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class CameraPatches
	{
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static void DisableTargetTextureOverride(Camera __instance, ref RenderTexture? value)
		{
			string name = ((Object)__instance).name;
			if ((name == "Camera Overlay" || name == "Camera Main") ? true : false)
			{
				value = null;
			}
		}

		[HarmonyPatch(typeof(CameraMainMenu), "Awake")]
		[HarmonyPostfix]
		private static void DisableMainMenuAnimation(CameraMainMenu __instance)
		{
			__instance.introLerp = 1f;
		}

		[HarmonyPatch(typeof(CameraAimOffset), "Awake")]
		[HarmonyPostfix]
		private static void DisableCameraAimOffset(CameraAimOffset __instance)
		{
			((Behaviour)__instance).enabled = false;
		}

		[HarmonyPatch(typeof(CameraTopFade), "Set")]
		[HarmonyPrefix]
		private static bool DisableCameraTopFade()
		{
			return false;
		}

		[HarmonyPatch(typeof(SemiFunc), "OnScreen")]
		[HarmonyPrefix]
		private static bool OnScreenVRPatch(Vector3 position, ref float paddWidth, ref float paddHeight, ref bool __result)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			float num = paddWidth;
			if (num < 0f && num >= -0.1f)
			{
				paddWidth -= 0.1f;
			}
			num = paddHeight;
			if (num < 0f && num >= -0.1f)
			{
				paddHeight -= 0.05f;
			}
			__result = OnScreenVR(position, paddWidth, paddHeight);
			return false;
		}

		private static bool OnScreenVR(Vector3 position, float padWidth, float padHeight)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = CameraUtils.Instance.MainCamera.WorldToViewportPoint(position);
			if (val.z < 0f)
			{
				return false;
			}
			if (val.x > 0f - padWidth && val.x < 1f + padWidth && val.y > 0f - padHeight)
			{
				return val.y < 1f + padHeight;
			}
			return false;
		}

		[HarmonyPatch(typeof(PlayerLocalCamera), "Update")]
		[HarmonyPostfix]
		private static void AlignWithVRCameraPatch(PlayerLocalCamera __instance)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (!SemiFunc.IsMultiplayer() || __instance.photonView.IsMine)
			{
				VRSession instance = VRSession.Instance;
				if (instance != null)
				{
					((Component)__instance).transform.position = ((Component)instance.MainCamera).transform.position;
					((Component)__instance).transform.rotation = ((Component)instance.MainCamera).transform.rotation;
				}
			}
		}

		[HarmonyPatch(typeof(PlayerLocalCamera), "OnPhotonSerializeView")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> CameraSerializeVRParams(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldsfld, (object)AccessTools.Field(typeof(CameraAim), "Instance"), (string)null)
			}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher matcher)
			{
				matcher.SetOpcodeAndAdvance(OpCodes.Ldarg_0);
			}, (Action<string>)null).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(PlayerLocalCamera), "GetOverrideActive")]
		[HarmonyPrefix]
		private static bool GetOverrideActivePatch(PlayerLocalCamera __instance, ref bool __result)
		{
			__result = __instance.clientPositionOverride || (__instance.playerAvatar.isLocal && VRCameraPosition.instance.overridePositionActive);
			return false;
		}

		[HarmonyPatch(typeof(PlayerAvatarMenuHover), "OnDestroy")]
		[HarmonyPostfix]
		private static void DisableMenuPlayerCamera(PlayerAvatarMenuHover __instance)
		{
			if (Object.op_Implicit((Object)(object)__instance.renderTextureInstance) && Object.op_Implicit((Object)(object)__instance.previewCamera))
			{
				((Behaviour)__instance.previewCamera).enabled = false;
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class DebugPatches
	{
		[HarmonyPatch(typeof(DebugTesterUI), "OnGUI")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> InjectVRTextPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldstr, (object)"{0}\n{1} ({2})", (string)null)
			}).SetOperandAndAdvance((object)"{0} (VR)\n{1} ({2})").InstructionEnumeration();
		}
	}
	internal static class HarmonyPatcher
	{
		private static readonly Harmony VRPatcher = new Harmony("io.daxcess.repoxr");

		private static readonly Harmony UniversalPatcher = new Harmony("io.daxcess.repoxr-universal");

		private static bool ignoreErrors;

		public static void PatchUniversal()
		{
			Patch(UniversalPatcher, RepoXRPatchTarget.Universal);
		}

		public static void PatchVR()
		{
			Patch(VRPatcher, RepoXRPatchTarget.VROnly);
		}

		public static void PatchClass(Type type)
		{
			UniversalPatcher.CreateClassProcessor(type, true).Patch();
		}

		private static void Patch(Harmony patcher, RepoXRPatchTarget target)
		{
			Harmony patcher2 = patcher;
			CollectionExtensions.Do<Type>((IEnumerable<Type>)AccessTools.GetTypesFromAssembly(Assembly.GetExecutingAssembly()), (Action<Type>)delegate(Type type)
			{
				try
				{
					RepoXRPatchAttribute repoXRPatchAttribute = (RepoXRPatchAttribute)Attribute.GetCustomAttribute(type, typeof(RepoXRPatchAttribute));
					if (repoXRPatchAttribute != null && (repoXRPatchAttribute.Dependency == null || Compat.IsLoaded(repoXRPatchAttribute.Dependency)) && repoXRPatchAttribute.Target == target)
					{
						Logger.LogDebug("Applying patches from: " + type.FullName);
						patcher2.CreateClassProcessor(type, true).Patch();
					}
				}
				catch (Exception ex)
				{
					Logger.LogError($"Failed to apply patches from {type}: {ex.Message}, {ex.InnerException}");
					if (!ignoreErrors)
					{
						switch (Native.ShellMessageBox(IntPtr.Zero, IntPtr.Zero, "One or more patches failed to apply correctly.\n\nThis version of RepoXR may not be compatible with this version of the game (" + Plugin.GameVersion + "),\nor other installed mods may be interfering with RepoXR.\n\nDo you want to continue loading the mod anyway? (NOT RECOMMENDED!)\n\nPressing 'No' will close the game.", "RepoXR v1.2.2 for R.E.P.O. v0.4.3", 65556u))
						{
						case 6:
							ignoreErrors = true;
							break;
						case 7:
							Process.GetCurrentProcess().Kill();
							break;
						}
					}
				}
			});
		}

		internal static void PatchNetworkRPCs()
		{
			Type[] typesFromAssembly = AccessTools.GetTypesFromAssembly(Assembly.GetCallingAssembly());
			for (int i = 0; i < typesFromAssembly.Length; i++)
			{
				ApplyNetworkRPCsForType(typesFromAssembly[i]);
			}
		}

		private static void ApplyNetworkRPCsForType(Type type)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			foreach (MethodInfo item in from m in type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
				where m.GetCustomAttribute<XRRpcAttribute>() != null
				select m)
			{
				XRRpcAttribute customAttribute = item.GetCustomAttribute<XRRpcAttribute>();
				PatchProcessor obj = UniversalPatcher.CreateProcessor((MethodBase)item);
				obj.AddPrefix(new HarmonyMethod(AccessTools.Method(typeof(NetworkingPatches), customAttribute.Self ? "ExecuteRPCPrefixSelf" : "ExecuteRPCPrefix", (Type[])null, (Type[])null)));
				obj.Patch();
			}
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	internal class RepoXRPatchAttribute : Attribute
	{
		public RepoXRPatchTarget Target { get; }

		public string? Dependency { get; }

		public RepoXRPatchAttribute(RepoXRPatchTarget target = RepoXRPatchTarget.VROnly, string? dependency = null)
		{
			Target = target;
			Dependency = dependency;
			base..ctor();
		}
	}
	internal enum RepoXRPatchTarget
	{
		Universal,
		VROnly
	}
	[RepoXRPatch(RepoXRPatchTarget.Universal, null)]
	[HarmonyPriority(800)]
	internal static class LeaveMyLeaveAlonePatch
	{
		[SpecialName]
		public sealed class <G>$B72F14756E5165C9D5FEFA1B795E3E9E
		{
			[SpecialName]
			public static class <M>$8957218503EBDF13BE7A0ABDF8D1D17D
			{
			}

			[ExtensionMarker("<M>$8957218503EBDF13BE7A0ABDF8D1D17D")]
			private LocalBuilder GetLocal(VariableDefinition varDef)
			{
				throw new NotSupportedException();
			}

			[ExtensionMarker("<M>$8957218503EBDF13BE7A0ABDF8D1D17D")]
			private void MarkBlockBefore(ExceptionBlock block)
			{
				throw new NotSupportedException();
			}

			[ExtensionMarker("<M>$8957218503EBDF13BE7A0ABDF8D1D17D")]
			private void MarkBlockAfter(ExceptionBlock block)
			{
				throw new NotSupportedException();
			}

			[ExtensionMarker("<M>$8957218503EBDF13BE7A0ABDF8D1D17D")]
			private void Emit(OpCode opcode, object operand)
			{
				throw new NotSupportedException();
			}
		}

		private static Type Type => AccessTools.TypeByName("HarmonyLib.Internal.Patching.ILManipulator");

		private static MethodInfo Method => AccessTools.Method(Type, "WriteTo", (Type[])null, (Type[])null);

		[UsedImplicitly]
		private static MethodBase TargetMethod()
		{
			return Method;
		}

		[UsedImplicitly]
		private static bool Prefix(object __instance, MethodBody body, MethodBase original)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			body.Instructions.Clear();
			body.ExceptionHandlers.Clear();
			CecilILGenerator il = new CecilILGenerator(body.GetILProcessor());
			ILGenerator proxy = ((ILGeneratorShim)il).GetProxy();
			((ILGeneratorShim)il).DefineLabel();
			foreach (CodeInstruction item in ApplyTranspilers(__instance, proxy, original, (Func<VariableDefinition, LocalBuilder>)((VariableDefinition vDef) => il.GetLocal(vDef)), (Func<Label>)((ILGeneratorShim)il).DefineLabel))
			{
				item.labels.ForEach(delegate(Label l)
				{
					((ILGeneratorShim)il).MarkLabel(l);
				});
				item.blocks.ForEach(delegate(ExceptionBlock b)
				{
					il.MarkBlockBefore(b);
				});
				if ((!(item.opcode == OpCodes.Endfilter) && !(item.opcode == OpCodes.Endfinally)) || item.blocks.Count <= 0)
				{
					switch (item.opcode.OperandType)
					{
					case OperandType.InlineNone:
						((ILGeneratorShim)il).Emit(item.opcode);
						break;
					case OperandType.InlineSig:
						throw new NotSupportedException("Emitting opcodes with CallSites is currently not fully implemented");
					default:
						if (item.operand == null)
						{
							throw new ArgumentNullException("operand", $"Invalid argument for {item}");
						}
						il.Emit(item.opcode, item.operand);
						break;
					}
				}
				item.blocks.ForEach(delegate(ExceptionBlock b)
				{
					il.MarkBlockAfter(b);
				});
			}
			if (body.Instructions.Count == 0)
			{
				((ILGeneratorShim)il).Emit(OpCodes.Ret);
			}
			return false;
		}

		private static IEnumerable<CodeInstruction> ApplyTranspilers(object instance, ILGenerator il, MethodBase original, Func<VariableDefinition, LocalBuilder> getLocal, Func<Label> defineLabel)
		{
			return (IEnumerable<CodeInstruction>)AccessTools.Method(Type, "ApplyTranspilers", (Type[])null, (Type[])null).Invoke(instance, new object[4] { il, original, getLocal, defineLabel });
		}

		private static LocalBuilder GetLocal(this CecilILGenerator il, VariableDefinition varDef)
		{
			return (LocalBuilder)AccessTools.Method(AccessTools.TypeByName("HarmonyLib.Internal.Util.EmitterExtensions"), "GetLocal", (Type[])null, (Type[])null).Invoke(null, new object[2] { il, varDef });
		}

		private static void MarkBlockBefore(this CecilILGenerator il, ExceptionBlock block)
		{
			AccessTools.Method(AccessTools.TypeByName("HarmonyLib.Internal.Util.EmitterExtensions"), "MarkBlockBefore", (Type[])null, (Type[])null).Invoke(null, new object[2] { il, block });
		}

		private static void MarkBlockAfter(this CecilILGenerator il, ExceptionBlock block)
		{
			AccessTools.Method(AccessTools.TypeByName("HarmonyLib.Internal.Util.EmitterExtensions"), "MarkBlockAfter", (Type[])null, (Type[])null).Invoke(null, new object[2] { il, block });
		}

		private static void Emit(this CecilILGenerator il, OpCode opcode, object operand)
		{
			AccessTools.Method(AccessTools.TypeByName("HarmonyLib.Internal.Util.EmitterExtensions"), "Emit", (Type[])null, (Type[])null).Invoke(null, new object[3] { il, opcode, operand });
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class InputPatches
	{
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static void AllowBackgroundTracking(ref BackgroundBehavior value)
		{
			value = (BackgroundBehavior)2;
		}

		[HarmonyPatch(typeof(InputManager), "Start")]
		[HarmonyPostfix]
		private static void OnInputManagerStart(InputManager __instance)
		{
			int num = Enum.GetNames(typeof(InputKey)).Length;
			for (int i = 0; i < AssetCollection.RemappableControls.additionalBindings.Length; i++)
			{
				InputActionReference val = AssetCollection.RemappableControls.additionalBindings[i];
				__instance.tagDictionary.Add("[" + val.action.name + "]", (InputKey)(i + num));
			}
		}

		[HarmonyPatch(typeof(InputManager), "InitializeInputs")]
		[HarmonyPostfix]
		private static void OnInitializeInputManager(InputManager __instance)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			new GameObject("VR Tracking Input").AddComponent<TrackingInput>();
		}

		[HarmonyPatch(typeof(InputManager), "GetAction")]
		[HarmonyPrefix]
		private static bool GetAction(ref InputKey key, ref InputAction __result)
		{
			int num = Enum.GetNames(typeof(InputKey)).Length;
			try
			{
				__result = (InputAction)(((int)key >= num) ? ((object)InputActionReference.op_Implicit(AssetCollection.RemappableControls.additionalBindings[(int)key - num])) : ((object)Actions.Instance[((object)(InputKey)(ref key)).ToString()]));
				return false;
			}
			catch
			{
				return true;
			}
		}

		[HarmonyPatch(typeof(InputManager), "GetMovement")]
		[HarmonyPrefix]
		private static bool GetMovement(InputManager __instance, ref Vector2 __result)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.disableMovementTimer > 0f)
			{
				return true;
			}
			if (__instance.disableControlsExceptTimer > 0f && !__instance.disableControlsExceptList.Contains((InputKey)0))
			{
				return true;
			}
			__result = Actions.Instance["Movement"].ReadValue<Vector2>();
			return false;
		}

		[HarmonyPatch(typeof(InputManager), "GetMovementAction")]
		[HarmonyPrefix]
		private static bool GetMovementAction(ref InputAction __result)
		{
			__result = Actions.Instance["Movement"];
			return false;
		}

		[HarmonyPatch(typeof(InputManager), "GetMovementX")]
		[HarmonyPrefix]
		private static bool GetMovementX(InputManager __instance, ref float __result)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.disableMovementTimer > 0f)
			{
				return true;
			}
			if (__instance.disableControlsExceptTimer > 0f && !__instance.disableControlsExceptList.Contains((InputKey)0))
			{
				return true;
			}
			__result = Actions.Instance["Movement"].ReadValue<Vector2>().x;
			return false;
		}

		[HarmonyPatch(typeof(InputManager), "GetMovementY")]
		[HarmonyPrefix]
		private static bool GetMovementY(InputManager __instance, ref float __result)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.disableMovementTimer > 0f)
			{
				return true;
			}
			if (__instance.disableControlsExceptTimer > 0f && !__instance.disableControlsExceptList.Contains((InputKey)0))
			{
				return true;
			}
			__result = Actions.Instance["Movement"].ReadValue<Vector2>().y;
			return false;
		}

		[HarmonyPatch(typeof(InputManager), "GetScrollY")]
		[HarmonyPrefix]
		private static bool GetScrollY(InputManager __instance, ref float __result)
		{
			__result = Actions.Instance["Scroll"].ReadValue<float>();
			return false;
		}

		[HarmonyPatch(typeof(InputManager), "KeyDown")]
		[HarmonyPrefix]
		private static bool KeyDown(InputManager __instance, ref InputKey key, ref bool __result)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Invalid comparison between Unknown and I4
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected I4, but got Unknown
			if (__instance.disableControlsExceptTimer > 0f && !__instance.disableControlsExceptList.Contains(key))
			{
				return true;
			}
			InputKey val = key;
			if (val - 1 > 1)
			{
				if ((int)val == 6)
				{
					if (((Behaviour)LoadingUI.instance).isActiveAndEnabled)
					{
						goto IL_00a4;
					}
					goto IL_00a9;
				}
				switch (val - 12)
				{
				case 0:
				case 2:
				case 7:
				case 8:
				case 9:
					break;
				case 11:
				case 12:
					goto IL_0087;
				default:
					goto IL_00a9;
				}
			}
			if (__instance.disableMovementTimer > 0f)
			{
				return true;
			}
			goto IL_00a9;
			IL_00a4:
			__result = false;
			return false;
			IL_0087:
			if (ChatManager.instance.chatActive || Object.op_Implicit((Object)(object)MenuManager.instance.currentMenuPage))
			{
				goto IL_00a4;
			}
			goto IL_00a9;
			IL_00a9:
			__result = __instance.GetAction(key).WasPressedThisFrame();
			return false;
		}

		[HarmonyPatch(typeof(InputManager), "KeyUp")]
		[HarmonyPrefix]
		private static bool KeyUp(InputManager __instance, ref InputKey key, ref bool __result)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Invalid comparison between Unknown and I4
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_002b: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			InputKey val = key;
			bool flag = (((int)val == 1 || (int)val == 12 || (int)val == 14) ? true : false);
			if (flag && __instance.disableMovementTimer > 0f)
			{
				return true;
			}
			val = key;
			if (val - 4 <= 1)
			{
				return true;
			}
			if (__instance.disableControlsExceptTimer > 0f && !__instance.disableControlsExceptList.Contains(key))
			{
				return true;
			}
			__result = __instance.GetAction(key).WasReleasedThisFrame();
			return false;
		}

		[HarmonyPatch(typeof(InputManager), "KeyHold")]
		[HarmonyPrefix]
		private static bool KeyHold(InputManager __instance, ref InputKey key, ref bool __result)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Invalid comparison between Unknown and I4
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			InputKey val = key;
			bool flag = (((int)val == 1 || (int)val == 12 || (int)val == 14) ? true : false);
			if (flag && __instance.disableMovementTimer > 0f)
			{
				return true;
			}
			if (__instance.disableControlsExceptTimer > 0f && !__instance.disableControlsExceptList.Contains(key))
			{
				return true;
			}
			__result = __instance.GetAction(key).IsPressed();
			return false;
		}

		[HarmonyPatch(typeof(InputManager), "KeyPullAndPush")]
		[HarmonyPrefix]
		private static bool KeyPullAndPush(ref float __result)
		{
			float num = Actions.Instance["Push"].ReadValue<float>();
			if (num > 0f)
			{
				__result = num;
				return false;
			}
			float num2 = Actions.Instance["Pull"].ReadValue<float>();
			if (num2 > 0f)
			{
				__result = 0f - num2;
			}
			return false;
		}

		[HarmonyPatch(typeof(InputManager), "InputDisplayGet")]
		[HarmonyPrefix]
		private static bool InputDisplayGet(InputManager __instance, InputKey _inputKey, ref string __result)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			InputAction action = __instance.GetAction(_inputKey);
			if (action == null)
			{
				__result = "Unassigned";
				return false;
			}
			int bindingIndex = InputActionRebindingExtensions.GetBindingIndex(action, VRInputSystem.Instance.CurrentControlScheme, (string)null);
			__result = __instance.InputDisplayGetString(action, bindingIndex);
			return false;
		}

		[HarmonyPatch(typeof(InputManager), "InputDisplayGetString")]
		[HarmonyPrefix]
		private static bool InputDisplayGetString(InputAction action, int bindingIndex, ref string __result)
		{
			//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_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			InputBinding val = action.bindings[bindingIndex];
			string effectivePath = ((InputBinding)(ref val)).effectivePath;
			__result = Utils.GetControlSpriteString(effectivePath);
			return false;
		}

		[HarmonyPatch(typeof(InputManager), "InputToggleGet")]
		[HarmonyPrefix]
		private static bool InputToggleGet(ref InputKey key, ref bool __result)
		{
			__result = VRInputSystem.Instance.InputToggleGet(((object)(InputKey)(ref key)).ToString());
			return false;
		}

		[HarmonyPatch(typeof(InputManager), "InputDisplayReplaceTags")]
		[HarmonyPrefix]
		private static bool NoUnderlinePatch(InputManager __instance, ref string __result, ref string _text)
		{
			InputManager __instance2 = __instance;
			_text = __instance2.tagDictionary.Aggregate(_text, (string current, KeyValuePair<string, InputKey> keyValuePair) => current.Replace(keyValuePair.Key, __instance2.InputDisplayGet(keyValuePair.Value, (KeyType)0, (MovementDirection)0)));
			__result = _text;
			return false;
		}

		[HarmonyPatch(typeof(MenuPageSettingsControls), "ResetControls")]
		[HarmonyPrefix]
		private static bool ResetVRControls()
		{
			RebindManager.Instance.ResetControls();
			return false;
		}

		[HarmonyPatch(typeof(MenuButton), "HoverLogic")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchHoverLogicMouseInputs(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			return PatchMouseInputs(new CodeMatcher(instructions, (ILGenerator)null)).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(MenuManager), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchMenuManagerMouseInputs(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			return PatchMouseInputs(new CodeMatcher(instructions, (ILGenerator)null)).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(MenuScrollBox), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchMenuScrollBoxMouseInputs(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			return PatchMouseInputs(new CodeMatcher(instructions, (ILGenerator)null)).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(MenuSlider), "PointerLogic")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchMenuSliderPointerLogicMouseInputs(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			return PatchMouseInputs(new CodeMatcher(instructions, (ILGenerator)null)).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(MenuSlider), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchMenuSliderUpdateMouseInputs(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			return PatchMouseInputs(new CodeMatcher(instructions, (ILGenerator)null)).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(MenuButtonArrow), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchMenuButtonArrowMouseInputs(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			return PatchMouseInputs(new CodeMatcher(instructions, (ILGenerator)null)).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(MenuElementRegion), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchMenuElementRegionMouseInputs(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			return PatchMouseInputs(new CodeMatcher(instructions, (ILGenerator)null)).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(MenuElementSaveFile), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchMenuElementSaveFile(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			return PatchMouseInputs(new CodeMatcher(instructions, (ILGenerator)null)).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(MenuElementServer), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchMenuElementServerMouseInputs(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			return PatchMouseInputs(new CodeMatcher(instructions, (ILGenerator)null)).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(MenuElementSliderPlayerMicGainSteam), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> MenuElementSliderPlayerMicGainSteamMouseInputs(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			return PatchMouseInputs(new CodeMatcher(instructions, (ILGenerator)null)).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(MenuPlayerListedSteam), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchMenuPlayerListedSteamMouseInputs(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			return PatchMouseInputs(new CodeMatcher(instructions, (ILGenerator)null)).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(Button), "OnPointerClick")]
		[HarmonyPrefix]
		private static bool PreventDoublePressPatch(Button __instance)
		{
			MenuButton val = default(MenuButton);
			return !((Component)__instance).TryGetComponent<MenuButton>(ref val);
		}

		private static bool GetMouseButtonVR(int button)
		{
			XRRayInteractorManager instance = XRRayInteractorManager.Instance;
			if (button != 0 || instance == null)
			{
				return Input.GetMouseButton(button);
			}
			return instance.GetTriggerButton();
		}

		private static bool GetMouseButtonDownVR(int button)
		{
			XRRayInteractorManager instance = XRRayInteractorManager.Instance;
			if (button != 0 || instance == null)
			{
				return Input.GetMouseButtonDown(button);
			}
			return instance.GetTriggerDown();
		}

		private static CodeMatcher PatchMouseInputs(this CodeMatcher matcher)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			CodeMatch val = new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Input), "GetMouseButton", (Type[])null, (Type[])null), (string)null);
			CodeMatch val2 = new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Input), "GetMouseButtonDown", (Type[])null, (Type[])null), (string)null);
			return matcher.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1] { val }).Repeat((Action<CodeMatcher>)delegate(CodeMatcher m)
			{
				m.SetOperandAndAdvance((object)new Func<int, bool>(GetMouseButtonVR).Method);
			}, (Action<string>)null).Start()
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1] { val2 })
				.Repeat((Action<CodeMatcher>)delegate(CodeMatcher m)
				{
					m.SetOperandAndAdvance((object)new Func<int, bool>(GetMouseButtonDownVR).Method);
				}, (Action<string>)null);
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class PhysGrabberPatches
	{
		[HarmonyPatch(typeof(PhysGrabber), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UpdatePatches(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(PlayerLocalCamera), "GetOverrideTransform", (Type[])null, (Type[])null), (string)null)
			}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher matcher)
			{
				matcher.Set(OpCodes.Call, (object)PlayerLocalCameraExtensions.GetHandOverrideTransformMethod);
			}, (Action<string>)null).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(PhysGrabber), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PushPullSlowdownPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_002b: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected O, but got Unknown
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)0.2f, (string)null)
			}).SetOperandAndAdvance((object)0.1f).Insert((CodeInstruction[])(object)new CodeInstruction[3]
			{
				new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(InputManager), "instance")),
				new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(InputManager), "KeyPullAndPush", (Type[])null, (Type[])null)),
				new CodeInstruction(OpCodes.Mul, (object)null)
			})
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)0.2f, (string)null)
				})
				.SetOperandAndAdvance((object)(-0.1f))
				.Insert((CodeInstruction[])(object)new CodeInstruction[3]
				{
					new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(InputManager), "instance")),
					new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(InputManager), "KeyPullAndPush", (Type[])null, (Type[])null)),
					new CodeInstruction(OpCodes.Mul, (object)null)
				})
				.InstructionEnumeration();
		}

		[HarmonyPatch(typeof(PhysGrabber), "Update")]
		[HarmonyPostfix]
		private static void HapticFeedbackPatch(PhysGrabber __instance)
		{
			if (__instance.isLocal && !(__instance.overrideGrabTimer > 0f))
			{
				float num = (__instance.grabbed ? (AssetCollection.GrabberHapticCurve.EvaluateTimed(__instance.loopSound.Source.pitch * 1.12667f) * 0.1f) : 0f);
				float num2 = __instance.physGrabBeamOverChargeFloat * 0.4f * AssetCollection.OverchargeHapticCurve.EvaluateTimed(__instance.physGrabBeamOverChargeFloat * 3f);
				if (!(num + num2 <= 0f))
				{
					HapticManager.Impulse(HapticManager.Hand.Dominant, HapticManager.Type.Continuous, num + num2);
				}
			}
		}

		[HarmonyPatch(typeof(PhysGrabber), "RayCheck")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> RayCheckPatches(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(PlayerLocalCamera), "GetOverrideTransform", (Type[])null, (Type[])null), (string)null)
			}).Set(OpCodes.Call, (object)PlayerLocalCameraExtensions.GetHandOverrideTransformMethod).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(PhysGrabber), "ObjectTurning")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ObjectTurningPatches(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldstr, (object)"Mouse X", (string)null)
			}).RemoveInstructions(10).Insert((CodeInstruction[])(object)new CodeInstruction[3]
			{
				new CodeInstruction(OpCodes.Ldloca_S, (object)(Plugin.GameDebugBuild ? 13 : 5)),
				new CodeInstruction(OpCodes.Ldloca_S, (object)(Plugin.GameDebugBuild ? 14 : 6)),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(PhysGrabberPatches), "GetRotationInput", (Type[])null, (Type[])null))
			})
				.InstructionEnumeration();
		}

		private static void GetRotationInput(out float x, out float y)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = Actions.Instance["Rotation"].ReadValue<Vector2>();
			x = val.x;
			y = val.y;
		}

		[HarmonyPatch(typeof(PhysGrabber), "ObjectTurning")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DisableTurningPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(SemiFunc), "InputHold", (Type[])null, (Type[])null), (string)null)
			}).Advance(1);
			CodeInstruction instruction = val.Instruction;
			val.Advance(1).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[5]
			{
				new CodeInstruction(OpCodes.Call, (object)AccessTools.PropertyGetter(typeof(VRSession), "Instance")),
				new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(VRSession), "Player")),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(VRPlayer), "disableRotateTimer")),
				new CodeInstruction(OpCodes.Ldc_R4, (object)0f),
				new CodeInstruction(OpCodes.Bgt_Un_S, instruction.operand)
			});
			return val.InstructionEnumeration();
		}

		[HarmonyPatch(typeof(PhysGrabber), "ReleaseObject")]
		[HarmonyPrefix]
		private static void OnReleaseObject(PhysGrabber __instance)
		{
			ItemEquippable item = default(ItemEquippable);
			if (__instance.grabbed && __instance.isLocal && Object.op_Implicit((Object)(object)__instance.grabbedObject) && ((Component)__instance.grabbedObject).TryGetComponent<ItemEquippable>(ref item))
			{
				VRSession.Instance?.Player.Rig.inventoryController.TryEquipItem(item);
			}
		}

		[HarmonyPatch(typeof(PhysGrabber), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ForceHoldPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(GameplayManager), "itemUnequipAutoHold"), (string)null)
			}).Advance(-2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[3]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(PhysGrabber), "overrideGrabTimer")),
				new CodeInstruction(OpCodes.Call, (object)new Func<bool, float, bool>(ShouldToggleGrabOff).Method)
			})
				.InstructionEnumeration();
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			static bool ShouldToggleGrabOff(bool grabHeld, float grabTimer)
			{
				if (grabHeld)
				{
					return grabTimer <= 0f;
				}
				return false;
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.Universal, null)]
	internal static class PhysGrabberUniversalPatches
	{
		[HarmonyPatch(typeof(PhysGrabber), "ObjectTurning")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ObjectTurningPatches(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(PlayerLocalCamera), "GetOverrideTransform", (Type[])null, (Type[])null), (string)null)
			}).Set(OpCodes.Call, (object)PlayerLocalCameraExtensions.GetHandOverrideTransformMethod).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(PlayerLocalCamera), "GetOverrideTransform", (Type[])null, (Type[])null), (string)null)
			})
				.Set(OpCodes.Call, (object)PlayerLocalCameraExtensions.GetHandOverrideTransformMethod)
				.InstructionEnumeration();
		}

		[HarmonyPatch(typeof(PhysGrabber), "StartGrabbingPhysObject")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> GrabFromHandPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(PlayerLocalCamera), "GetOverrideTransform", (Type[])null, (Type[])null), (string)null)
			}).Set(OpCodes.Call, (object)PlayerLocalCameraExtensions.GetHandOverrideTransformMethod).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(PhysGrabber), "GrabStateClimb")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> HandBasedTumbleClimbPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Quaternion), "Angle", (Type[])null, (Type[])null), (string)null)
			}).Advance(-5).SetAndAdvance(OpCodes.Call, (object)new Func<PhysGrabber, Quaternion>(GetRotation).Method)
				.RemoveInstruction()
				.InstructionEnumeration();
			static Quaternion GetRotation(PhysGrabber grabber)
			{
				//IL_0060: 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_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				if (grabber.playerAvatar.isLocal)
				{
					if (!VRSession.InVR)
					{
						return grabber.climbStickTransform.rotation;
					}
					return VRSession.Instance.Player.MainHand.rotation * Quaternion.Euler(0f, 180f, 0f);
				}
				if (!Object.op_Implicit((Object)(object)NetworkSystem.instance))
				{
					return grabber.climbStickTransform.rotation;
				}
				if (!NetworkSystem.instance.GetNetworkPlayer(grabber.playerAvatar, out NetworkPlayer networkPlayer))
				{
					return grabber.climbStickTransform.rotation;
				}
				return networkPlayer.PrimaryHand.rotation * Quaternion.Euler(0f, 180f, 0f);
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.Universal, null)]
	internal static class PhysGrabObjectPatches
	{
		private static Transform GetCartSteerTransform(PhysGrabber grabber)
		{
			if (grabber.playerAvatar.isLocal)
			{
				VRSession instance = VRSession.Instance;
				if (instance == null)
				{
					return ((Component)grabber).transform;
				}
				return instance.Player.MainHand;
			}
			if (!NetworkSystem.instance.GetNetworkPlayer(grabber.playerAvatar, out NetworkPlayer networkPlayer))
			{
				return ((Component)grabber).transform;
			}
			return networkPlayer.PrimaryHand;
		}

		[HarmonyPatch(typeof(PhysGrabObject), "PhysicsGrabbingManipulation")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> HandRelativeMovementPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(PlayerLocalCamera), "GetOverrideTransform", (Type[])null, (Type[])null), (string)null)
			}).Set(OpCodes.Call, (object)PlayerLocalCameraExtensions.GetHandOverrideTransformMethod).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(PhysGrabCart), "CartSteer")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> HandRelativeCartPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Expected O, but got Unknown
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Expected O, but got Unknown
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Mathf), "Clamp", new Type[3]
				{
					typeof(float),
					typeof(float),
					typeof(float)
				}, (Type[])null), (string)null)
			}).MatchBack(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(Component), "transform"), (string)null)
			}).SetInstruction(new CodeInstruction(OpCodes.Call, (object)new Func<PhysGrabber, Transform>(GetCartSteerTransform).Method))
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(Transform), "rotation"), (string)null)
				})
				.Advance(-1)
				.SetInstruction(new CodeInstruction(OpCodes.Call, (object)new Func<PhysGrabber, Transform>(GetCartSteerTransform).Method))
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Quaternion), "LookRotation", new Type[2]
					{
						typeof(Vector3),
						typeof(Vector3)
					}, (Type[])null), (string)null)
				})
				.Advance(-7)
				.SetInstruction(new CodeInstruction(OpCodes.Call, (object)new Func<PhysGrabber, Transform>(GetCartSteerTransform).Method))
				.InstructionEnumeration();
		}

		[HarmonyPatch(typeof(ItemCartCannonMain), "GrabLogic")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> HandRelativeCartCannonPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(PlayerLocalCamera), "GetOverrideTransform", (Type[])null, (Type[])null), (string)null)
			}).SetAndAdvance(OpCodes.Call, (object)new Func<PlayerLocalCamera, Transform>(PlayerLocalCameraExtensions.GetHandOverrideTransform).Method).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(ItemCartCannonMain), "CorrectorAndLightLogic")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> RotationTargetHandRelative(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(PlayerLocalCamera), "GetOverrideTransform", (Type[])null, (Type[])null), (string)null)
			}).Set(OpCodes.Call, (object)PlayerLocalCameraExtensions.GetHandOverrideTransformMethod).InstructionEnumeration();
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class PostProcessingPatches
	{
		[HarmonyPatch(typeof(PostProcessing), "Start")]
		[HarmonyPostfix]
		private static void PostProcessingPatch(PostProcessing __instance)
		{
			((PostProcessEffectSettings)__instance.lensDistortion).active = false;
			((PostProcessEffectSettings)__instance.chromaticAberration).active = false;
		}

		[HarmonyPatch(typeof(GraphicsManager), "UpdateLensDistortion")]
		[HarmonyPrefix]
		private static bool DisableLensDistortion()
		{
			return false;
		}

		[HarmonyPatch(typeof(GraphicsManager), "UpdateChromaticAberration")]
		[HarmonyPrefix]
		private static bool DisableChromaticAberration()
		{
			return false;
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class PresencePatches
	{
		[HarmonyPatch(typeof(DiscordManager), "UpdateDiscordRichPresence")]
		[HarmonyPrefix]
		private static void DiscordVRPresence(ref string details)
		{
			details = details.StripSuffix(" [VR]");
			if (!Plugin.Config.DisableVRPresence.Value)
			{
				details += " [VR]";
			}
		}

		[HarmonyPatch(typeof(RunManager), "UpdateSteamRichPresence")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> SteamVRPresence(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0022: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(true, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldloc_3, (object)null, (string)null)
			}).Advance(1).Insert((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Call, (object)new Func<string, string>(GetSteamPresence).Method)
			})
				.InstructionEnumeration();
			static string GetSteamPresence(string levelName)
			{
				if (Plugin.Config.DisableVRPresence.Value)
				{
					return levelName;
				}
				return levelName + " [VR]";
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class SpectatePatches
	{
		private static bool turnedLastInput;

		private static float spectateTurnAmount;

		[HarmonyPatch(typeof(SpectateCamera), "UpdateState")]
		[HarmonyPostfix]
		private static void OnUpdateState(SpectateCamera __instance, State _state)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)CameraAimOffset.Instance).transform;
			if ((int)_state == 0)
			{
				transform.localEulerAngles = ((Component)Camera.main).transform.localEulerAngles.y * Vector3.down;
				transform.localPosition = Vector3.back * 10f;
			}
			else
			{
				transform.localRotation = Quaternion.identity;
				transform.localPosition = Vector3.zero;
			}
		}

		[HarmonyPatch(typeof(SpectateCamera), "DeathNearClipLogic")]
		[HarmonyPostfix]
		private static void NearClipPatches(SpectateCamera __instance)
		{
			__instance.MainCamera.nearClipPlane = 0.01f;
		}

		[HarmonyPatch(typeof(SpectateCamera), "StateDeath")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> IncreaseFarPlanePatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_002b: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)90f, (string)null)
			}).SetOperandAndAdvance((object)180f).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(SpectateCamera), "StateDeath")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DisableMouseRotationPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Quaternion), "Euler", new Type[3]
				{
					typeof(float),
					typeof(float),
					typeof(float)
				}, (Type[])null), (string)null)
			}).Advance(-3).RemoveInstructions(2)
				.Insert((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Ldc_R4, (object)0f)
				})
				.InstructionEnumeration();
		}

		[HarmonyPatch(typeof(SpectateCamera), "StateNormal")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> CameraRotationPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Expected O, but got Unknown
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Expected O, but got Unknown
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Expected O, but got Unknown
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Expected O, but got Unknown
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.PropertySetter(typeof(RenderSettings), "fogStartDistance"), (string)null)
			}).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertySetter(typeof(Transform), "position"), (string)null)
			}).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[5]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SpectateCamera), "MainCamera")),
				new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(Component), "transform")),
				new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(Transform), "localPosition")),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Vector3), "op_Subtraction", (Type[])null, (Type[])null))
			})
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertySetter(typeof(Transform), "rotation"), (string)null)
				})
				.Advance(-3)
				.RemoveInstructions(3)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[4]
				{
					new CodeInstruction(OpCodes.Ldc_R4, (object)0f),
					new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(SpectatePatches), "spectateTurnAmount")),
					new CodeInstruction(OpCodes.Ldc_R4, (object)0f),
					new CodeInstruction(OpCodes.Newobj, (object)AccessTools.Constructor(typeof(Vector3), new Type[3]
					{
						typeof(float),
						typeof(float),
						typeof(float)
					}, false))
				})
				.SetOperandAndAdvance((object)AccessTools.PropertySetter(typeof(Transform), "eulerAngles"))
				.InstructionEnumeration();
		}

		[HarmonyPatch(typeof(SpectateCamera), "StateNormal")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> InputPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(SemiFunc), "InputMouseX", (Type[])null, (Type[])null), (string)null)
			}).SetOperandAndAdvance((object)new Func<float>(GetRotationX).Method).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(SemiFunc), "InputMouseY", (Type[])null, (Type[])null), (string)null)
			})
				.SetOperandAndAdvance((object)new Func<float>(GetRotationY).Method)
				.InstructionEnumeration();
			static float GetRotationX()
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				return 0f - Actions.Instance["Movement"].ReadValue<Vector2>().x;
			}
			static float GetRotationY()
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				return 0f - Actions.Instance["Movement"].ReadValue<Vector2>().y;
			}
		}

		[HarmonyPatch(typeof(SpectateCamera), "StateNormal")]
		[HarmonyPostfix]
		private static void CameraTurnPatch(SpectateCamera __instance)
		{
			float num = Actions.Instance["Turn"].ReadValue<float>();
			switch (Plugin.Config.TurnProvider.Value)
			{
			case Config.TurnProviderOption.Snap:
			{
				bool flag = Mathf.Abs(num) > 0.75f;
				float value = Plugin.Config.SnapTurnSize.Value;
				if (!turnedLastInput && flag)
				{
					if (num > 0f)
					{
						spectateTurnAmount += value;
					}
					else
					{
						spectateTurnAmount -= value;
					}
				}
				turnedLastInput = flag;
				break;
			}
			case Config.TurnProviderOption.Smooth:
				if (!Plugin.Config.AnalogSmoothTurn.Value)
				{
					num = ((num != 0f) ? Math.Sign(num) : 0);
				}
				spectateTurnAmount += 180f * Time.deltaTime * Plugin.Config.SmoothTurnSpeedModifier.Value * num;
				break;
			case Config.TurnProviderOption.Disabled:
				break;
			}
		}

		[HarmonyPatch(typeof(SpectateCamera), "StateHead")]
		[HarmonyPostfix]
		private static void HeadCameraTurnPatch(SpectateCamera __instance)
		{
			float num = Actions.Instance["Turn"].ReadValue<float>();
			switch (Plugin.Config.TurnProvider.Value)
			{
			case Config.TurnProviderOption.Snap:
			{
				bool flag = Mathf.Abs(num) > 0.75f;
				float value = Plugin.Config.SnapTurnSize.Value;
				if (!turnedLastInput && flag)
				{
					if (num > 0f)
					{
						VRCameraAim.instance.TurnAimNow(value);
					}
					else
					{
						VRCameraAim.instance.TurnAimNow(0f - value);
					}
				}
				turnedLastInput = flag;
				break;
			}
			case Config.TurnProviderOption.Smooth:
				if (!Plugin.Config.AnalogSmoothTurn.Value)
				{
					num = ((num != 0f) ? Math.Sign(num) : 0);
				}
				VRCameraAim.instance.TurnAimNow(180f * Time.deltaTime * Plugin.Config.SmoothTurnSpeedModifier.Value * num);
				break;
			case Config.TurnProviderOption.Disabled:
				break;
			}
		}

		[HarmonyPatch(typeof(SpectateCamera), "StateHead")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> AlignCameraWithHeadPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.PropertyGetter(typeof(Time), "deltaTime"), (string)null)
			}).Advance(-3).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null)
			})
				.SetAndAdvance(OpCodes.Call, (object)new Func<PlayerDeathHead, SpectateCamera, Vector3>(GetTargetPoint).Method)
				.RemoveInstruction()
				.InstructionEnumeration();
			static Vector3 GetTargetPoint(PlayerDeathHead head, SpectateCamera camera)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: 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_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_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = ((Component)camera).transform.InverseTransformPoint(((Component)Camera.main).transform.position);
				return head.physGrabObject.centerPoint - ((Component)camera).transform.rotation * val;
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class XRPatches
	{
		[HarmonyPatch(typeof(XRSupport), "Initialize")]
		[HarmonyPrefix]
		private static bool OnBeforeInitialize()
		{
			return false;
		}
	}
}
namespace RepoXR.Patches.Valuables
{
	[RepoXRPatch(RepoXRPatchTarget.Universal, null)]
	internal static class ValuableArcticSnowBikePatches
	{
		[HarmonyPatch(typeof(ValuableArcticSnowBike), "UpdateSteering")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> BikeHandSteeringPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(PlayerAvatar), "localCamera"), (string)null)
			}).Set(OpCodes.Call, (object)new Func<PlayerAvatar, Transform>(GetSourceTransform).Method).InstructionEnumeration();
			static Transform GetSourceTransform(PlayerAvatar player)
			{
				if (player.isLocal)
				{
					if (!VRSession.InVR)
					{
						return ((Component)player.localCamera).transform;
					}
					return VRSession.Instance.Player.MainHand;
				}
				if (!Object.op_Implicit((Object)(object)NetworkSystem.instance))
				{
					return ((Component)player.localCamera).transform;
				}
				if (!NetworkSystem.instance.GetNetworkPlayer(player, out NetworkPlayer networkPlayer))
				{
					return ((Component)player.localCamera).transform;
				}
				return networkPlayer.PrimaryHand;
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class ValuableCrystalBallPatches
	{
		private static float crystalBallPlayerRotation;

		[HarmonyPatch(typeof(CrystalBallValuable), "StateActive")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> LookAtPlayerPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(CameraAim), "AimTargetSet", (Type[])null, (Type[])null), (string)null)
			}).MatchBack(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldsfld, (object)AccessTools.Field(typeof(CameraAim), "Instance"), (string)null)
			}).SetOperandAndAdvance((object)AccessTools.Field(typeof(VRCameraAim), "instance"))
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(CameraAim), "AimTargetSet", (Type[])null, (Type[])null), (string)null)
				})
				.SetAndAdvance(OpCodes.Call, (object)Plugin.GetConfigGetter())
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[3]
				{
					new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(Config), "ReducedAimImpact")),
					new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(ConfigEntry<bool>), "Value")),
					new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(VRCameraAim), "SetAimTarget", (Type[])null, (Type[])null))
				})
				.InstructionEnumeration();
		}

		[HarmonyPatch(typeof(CrystalBallValuable), "StateActive")]
		[HarmonyPrefix]
		private static void UpdateCrystalBallRotation(CrystalBallValuable __instance)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.physGrabObject.playerGrabbing.Count != 0 && __instance.physGrabObject.playerGrabbing.Contains(PlayerAvatar.instance.physGrabber))
			{
				if (!__instance.activeLocal)
				{
					crystalBallPlayerRotation = ((Component)GameDirector.instance.MainCamera).transform.eulerAngles.y;
				}
				float num = Actions.Instance["Turn"].ReadValue<float>();
				if (!Plugin.Config.AnalogSmoothTurn.Value)
				{
					num = ((num != 0f) ? Math.Sign(num) : 0);
				}
				crystalBallPlayerRotation += 180f * Time.deltaTime * num * 0.5f;
				if (crystalBallPlayerRotation > 360f)
				{
					crystalBallPlayerRotation -= 360f;
				}
				if (crystalBallPlayerRotation < 0f)
				{
					crystalBallPlayerRotation += 360f;
				}
			}
		}

		[HarmonyPatch(typeof(CrystalBallValuable), "StateActive")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ArmMovePatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Quaternion), "Euler", new Type[3]
				{
					typeof(float),
					typeof(float),
					typeof(float)
				}, (Type[])null), (string)null)
			}).SetOperandAndAdvance((object)new Func<CrystalBallValuable, Quaternion>(GetRotationAngle).Method).Advance(-5)
				.RemoveInstructions(4)
				.InstructionEnumeration();
			static Quaternion GetRotationAngle(CrystalBallValuable valuable)
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: 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)
				VRSession instance = VRSession.Instance;
				if (instance == null)
				{
					return Quaternion.Euler(valuable.aimVertical, valuable.aimHorizontal, 0f);
				}
				Quaternion val = Quaternion.LookRotation(-(VRSession.IsLeftHanded ? instance.Player.Rig.leftArmTarget : instance.Player.Rig.rightArmTarget).forward);
				return Quaternion.Euler(((Quaternion)(ref val)).eulerAngles.x, crystalBallPlayerRotation, 0f);
			}
		}

		[HarmonyPatch(typeof(CrystalBallValuable), "ResetCameraAim")]
		[HarmonyPostfix]
		private static void ResetCameraAim(CrystalBallValuable __instance)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			VRCameraAim.instance.SetPlayerAim(((Quaternion)(ref __instance.lastPlayerRotation)).eulerAngles.y, forceInitial: true);
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class MusicBoxTrapPatches
	{
		[HarmonyPatch(typeof(MusicBoxTrap), "Update")]
		[HarmonyPostfix]
		private static void RotatePlayerPatch(MusicBoxTrap __instance)
		{
			if (__instance.MusicBoxPlaying && Object.op_Implicit((Object)(object)PhysGrabber.instance) && !((Object)(object)PhysGrabber.instance.grabbedObject != (Object)(object)__instance.rb))
			{
				VRCameraAim.instance.TurnAimNow(90f * Time.deltaTime);
			}
		}
	}
}
namespace RepoXR.Patches.UI
{
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class ArrowPatches
	{
		[HarmonyPatch(typeof(ArrowUI), "Awake")]
		[HarmonyPostfix]
		private static void OnArrowUICreate(ArrowUI __instance)
		{
			((Behaviour)__instance).enabled = false;
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class ChatPatches
	{
		[HarmonyPatch(typeof(ChatUI), "Start")]
		[HarmonyPostfix]
		private static void OnChatUICreate(ChatUI __instance)
		{
			((Component)__instance).gameObject.AddComponent<ChatUI>();
		}

		[HarmonyPatch(typeof(ChatManager), "StateInactive")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ChatOpenButtonPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(SemiFunc), "InputDown", (Type[])null, (Type[])null), (string)null)
			}).Advance(-1).SetAndAdvance(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(VRInputSystem), "_instance"))
				.SetAndAdvance(OpCodes.Callvirt, (object)AccessTools.Method(typeof(VRInputSystem), "ChatPressed", (Type[])null, (Type[])null))
				.InstructionEnumeration();
		}

		[HarmonyPatch(typeof(ChatManager), "StateActive")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ChatCloseButtonPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldc_I4_S, (object)(sbyte)18, (string)null)
			}).SetAndAdvance(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(VRInputSystem), "_instance")).SetAndAdvance(OpCodes.Callvirt, (object)AccessTools.Method(typeof(VRInputSystem), "ChatPressed", (Type[])null, (Type[])null))
				.InstructionEnumeration();
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class CrosshairPatches
	{
		[HarmonyPatch(typeof(Aim), "Awake")]
		[HarmonyPostfix]
		private static void OnCrosshairCreate(Aim __instance)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			Canvas val = new GameObject("Crosshair").AddComponent<Canvas>();
			GameObject val2 = new GameObject("Crosshair Offset");
			val2.transform.parent = ((Component)val).transform;
			val2.transform.localEulerAngles = new Vector3(270f, 270f, 0f);
			GameObject val3 = val2;
			RectTransform component = ((Component)val).GetComponent<RectTransform>();
			val.renderMode = (RenderMode)2;
			component.sizeDelta = new Vector2(40f, 40f);
			((Transform)component).localScale = Vector3.one * 0.01f;
			((Component)__instance).transform.parent = val3.transform;
			((Component)__instance).transform.localPosition = Vector3.zero;
			((Component)__instance).transform.localRotation = Quaternion.identity;
			((Component)__instance).transform.localScale = Vector3.one;
			((Component)val).gameObject.AddComponent<Crosshair>();
		}

		[HarmonyPatch(typeof(OverchargeRoundBarUI), "Start")]
		[HarmonyPostfix]
		private static void OnOverchargeCreate(OverchargeRoundBarUI __instance)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			((Component)__instance).transform.SetParent(((Component)Crosshair.instance).transform, false);
			((Component)__instance).transform.localEulerAngles = new Vector3(-90f, -90f, 0f);
			((Component)__instance).transform.localPosition = Vector3.zero;
			((Component)__instance).transform.localScale = Vector3.one * 0.65f;
			GameObjectExtensions.SetLayerRecursively(((Component)Crosshair.instance).gameObject, 5);
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class InfoTextTriggerFinderPatches
	{
		[HarmonyPatch(typeof(InfoTextTriggerFinder), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> RaycastFromArmPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(PlayerLocalCamera), "GetOverrideTransform", (Type[])null, (Type[])null), (string)null)
			}).Set(OpCodes.Call, (object)PlayerLocalCameraExtensions.GetHandOverrideTransformMethod).InstructionEnumeration();
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class InventoryUIPatches
	{
		[HarmonyPatch(typeof(InventorySpot), "Start")]
		[HarmonyPostfix]
		private static void DisableBunchOfUIPatch(InventorySpot __instance)
		{
			((Behaviour)((Component)__instance).GetComponent<RawImage>()).enabled = false;
			((Behaviour)((Component)__instance).GetComponentInChildren<Image>()).enabled = false;
			CollectionExtensions.Do<TextMeshProUGUI>((IEnumerable<TextMeshProUGUI>)((Component)__instance).GetComponentsInChildren<TextMeshProUGUI>(), (Action<TextMeshProUGUI>)delegate(TextMeshProUGUI comp)
			{
				((Behaviour)comp).enabled = false;
			});
		}

		[HarmonyPatch(typeof(InventorySpot), "UpdateUI")]
		[HarmonyPostfix]
		private static void DisableUIOnceAgain(InventorySpot __instance)
		{
			((Behaviour)__instance.inventoryIcon).enabled = false;
			((Behaviour)__instance.noItem).enabled = false;
		}

		[HarmonyPatch(typeof(ItemInfoUI), "Start")]
		[HarmonyPostfix]
		private static void ItemInfoControlsPatch(ItemInfoUI __instance)
		{
			((TMP_Text)__instance.Text).spriteAsset = AssetCollection.TMPInputsSpriteAsset;
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class LoadingUIPatches
	{
		[HarmonyPatch(typeof(LoadingUI), "StartLoading")]
		[HarmonyPostfix]
		private static void OnStartLoading()
		{
			Object.FindObjectOfType<LoadingUI>()?.ResetPosition();
		}

		[HarmonyPatch(typeof(LoadingUI), "Awake")]
		[HarmonyPostfix]
		private static void StuckTextPatches(LoadingUI __instance)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			((TMP_Text)__instance.stuckText).spriteAsset = AssetCollection.TMPInputsSpriteAsset;
			GameObject val = new GameObject("Stuck Text Mask");
			val.transform.parent = ((Component)__instance).transform;
			val.transform.localPosition = Vector3.zero;
			val.transform.localRotation = Quaternion.identity;
			RectTransform component = ((Component)val.AddComponent<RectMask2D>()).GetComponent<RectTransform>();
			RectTransform component2 = ((Component)__instance).GetComponent<RectTransform>();
			component.sizeDelta = component2.sizeDelta;
			((Transform)__instance.stuckTransform).SetParent((Transform)(object)component, false);
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class LobbyMenuPatches
	{
		[HarmonyPatch(typeof(MenuPageLobby), "UpdateChatPrompt")]
		[HarmonyPostfix]
		private static void UpdateChatPromptSprites(MenuPageLobby __instance)
		{
			((TMP_Text)__instance.chatPromptText).spriteAsset = AssetCollection.TMPInputsSpriteAsset;
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class MenuButtonPatches
	{
		[HarmonyPatch(typeof(MenuButton), "ResizeToText")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> MiddleAlignFixPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(Transform), "position"), (string)null)
			}).SetOperandAndAdvance((object)AccessTools.PropertyGetter(typeof(Transform), "localPosition")).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertySetter(typeof(Transform), "position"), (string)null)
			})
				.SetOperandAndAdvance((object)AccessTools.PropertySetter(typeof(Transform), "localPosition"))
				.InstructionEnumeration();
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class MenuPageSavesPatches
	{
		[HarmonyPatch(typeof(MenuPageSavesRename), "ButtonConfirm")]
		[HarmonyPostfix]
		private static void OnConfirm()
		{
			InputKeyboard instance = InputKeyboard.instance;
			if (instance != null && (Object)(object)instance != (Object)null)
			{
				instance.Close();
			}
		}

		[HarmonyPatch(typeof(MenuPageSavesRename), "ExitPage")]
		[HarmonyPostfix]
		private static void OnExitPage()
		{
			InputKeyboard instance = InputKeyboard.instance;
			if (instance != null && (Object)(object)instance != (Object)null)
			{
				instance.Close();
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.Universal, null)]
	internal static class MenuPatches
	{
		[HarmonyPatch(typeof(MenuManager), "Awake")]
		[HarmonyPrefix]
		private static void OnMenuManagerStart(MenuManager __instance)
		{
			if (!Object.op_Implicit((Object)(object)MenuManager.instance))
			{
				MenuHelper.RegisterCustomMenus(__instance);
			}
		}

		[HarmonyPatch(typeof(MenuPageSettings), "Start")]
		[HarmonyPostfix]
		private static void AddVRSettingsPatch(MenuPageSettings __instance)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			MenuPageSettings __instance2 = __instance;
			if (SemiFunc.MenuLevel() || VRSession.InVR)
			{
				Button component = Object.Instantiate<GameObject>(AssetCollection.VRSettingsButton, ((Component)__instance2).transform).GetComponent<Button>();
				((Component)component).GetComponent<RectTransform>().anchoredPosition = new Vector2(126f, 83f);
				((UnityEvent)component.onClick).AddListener((UnityAction)delegate
				{
					__instance2.ButtonEventBack();
					MenuHelper.PageOpenOnTop(MenuHelper.RepoXRMenuPage.VRSettings);
				});
				((Component)((Component)__instance2).transform.Find("Menu Button - Back")).GetComponent<RectTransform>().anchoredPosition = new Vector2(126f, 35f);
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class MenuTextInputPatches
	{
		[HarmonyPatch(typeof(MenuTextInput), "Start")]
		[HarmonyPostfix]
		private static void OnMenuTextInputCreate(MenuTextInput __instance)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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)
			RectTransform component = ((Component)((Component)__instance).GetComponentInParent<Canvas>()).GetComponent<RectTransform>();
			GameObject val = new GameObject("Keyboard Scale");
			val.transform.position = ((Transform)component).TransformPoint(new Vector3(component.sizeDelta.x / 2f, -100f, 0f));
			val.transform.rotation = ((Transform)component).rotation * Quaternion.Euler(15f, 0f, 0f);
			Transform transform = val.transform;
			Object.Instantiate<GameObject>(AssetCollection.Keyboard, transform).transform.localScale = Vector3.one * 0.0175f;
			((Component)transform).gameObject.AddComponent<InputKeyboard>().menuInput = __instance;
		}

		[HarmonyPatch(typeof(MenuTextInput), "InputTextSet")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> TextCursorPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(Transform), "position"), (string)null)
			}).SetOperandAndAdvance((object)AccessTools.PropertyGetter(typeof(Transform), "localPosition")).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertySetter(typeof(Transform), "position"), (string)null)
			})
				.SetOperandAndAdvance((object)AccessTools.PropertySetter(typeof(Transform), "localPosition"))
				.InstructionEnumeration();
		}

		[HarmonyPatch(typeof(MenuPageServerListCreateNew), "ExitPage")]
		[HarmonyPostfix]
		private static void OnCreateServerButtonExit()
		{
			InputKeyboard.instance.Close();
		}

		[HarmonyPatch(typeof(MenuPageServerListCreateNew), "ButtonConfirm")]
		[HarmonyPostfix]
		private static void OnCreateServerButtonConfirm()
		{
			InputKeyboard.instance.Close();
		}

		[HarmonyPatch(typeof(MenuPageServerListSearch), "ExitPage")]
		[HarmonyPostfix]
		private static void OnSearchServerButtonExit()
		{
			InputKeyboard.instance.Close();
		}

		[HarmonyPatch(typeof(MenuPageServerListSearch), "ButtonConfirm")]
		[HarmonyPostfix]
		private static void OnSearchServerButtonConfirm()
		{
			InputKeyboard.instance.Close();
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class MoonUIPatches
	{
		[HarmonyPatch(typeof(MoonUI), "Awake")]
		[HarmonyPostfix]
		private static void OnMoonUICreate(MoonUI __instance)
		{
			__instance.showStartPosition = 300f;
			__instance.skipStartPosition = -240f;
			((TMP_Text)__instance.skipText).spriteAsset = AssetCollection.TMPInputsSpriteAsset;
		}

		[HarmonyPatch(typeof(MoonUI), "StateNone")]
		[HarmonyPostfix]
		private static void OnStateNone(MoonUI __instance)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: 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)
			((Transform)__instance.topCornerTransformLeft).localEulerAngles = new Vector3(0f, -25f, 0f);
			((Transform)__instance.topCornerTransformRight).localEulerAngles = new Vector3(0f, 25f, 0f);
			((Transform)__instance.botCornerTransformLeft).localEulerAngles = new Vector3(0f, -25f, 0f);
			((Transform)__instance.botCornerTransformRight).localEulerAngles = new Vector3(0f, 25f, 0f);
		}

		[HarmonyPatch(typeof(MoonUI), "Update")]
		[HarmonyPostfix]
		private static void OnMoonUIUpdate(MoonUI __instance)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Invalid comparison between Unknown and I4
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			((Graphic)__instance.backgroundImage).color = Color.clear;
			State state = __instance.state;
			if ((int)state >= 3 && (int)state < 8)
			{
				((Graphic)FadeOverlay.Instance.Image).color = new Color(0f, 0f, 0f, __instance.showCurve.Evaluate(__instance.showLerp) * 0.5f);
			}
			else if ((int)__instance.state == 8)
			{
				((Graphic)FadeOverlay.Instance.Image).color = new Color(0f, 0f, 0f, 0.5f - __instance.hideCurve.Evaluate(__instance.hideLerp) * 0.5f);
			}
		}

		[HarmonyPatch(typeof(MoonUI), "SetState")]
		[HarmonyPostfix]
		private static void OnSetState(State _state)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if ((int)_state == 0)
			{
				((Graphic)FadeOverlay.Instance.Image).color = Color.clear;
			}
			else if ((int)_state == 3)
			{
				LoadingUI.instance.ResetPosition();
			}
		}

		[HarmonyPatch(typeof(MoonUI), "MoonRotateLogic")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> MoonRotationFix(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertySetter(typeof(Transform), "rotation"), (string)null)
			}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher matcher)
			{
				matcher.SetOperandAndAdvance((object)AccessTools.PropertySetter(typeof(Transform), "localRotation"));
			}, (Action<string>)null).InstructionEnumeration();
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class PasswordMenuPatches
	{
		[HarmonyPatch(typeof(MenuPagePassword), "Start")]
		[HarmonyPostfix]
		private static void OnMenuPagePasswordShown(MenuPagePassword __instance)
		{
			((Component)__instance).gameObject.AddComponent<PasswordUI>();
		}

		[HarmonyPatch(typeof(MenuPagePassword), "ConfirmButton")]
		[HarmonyPostfix]
		private static void OnMenuPagePasswordConfirm(MenuPagePassword __instance)
		{
			((Component)__instance).GetComponent<PasswordUI>().OnConfirm();
		}

		[HarmonyPatch(typeof(MenuPagePassword), "PasswordTextSet")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> TextCursorPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(Transform), "position"), (string)null)
			}).SetOperandAndAdvance((object)AccessTools.PropertyGetter(typeof(Transform), "localPosition")).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertySetter(typeof(Transform), "position"), (string)null)
			})
				.SetOperandAndAdvance((object)AccessTools.PropertySetter(typeof(Transform), "localPosition"))
				.InstructionEnumeration();
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class PauseMenuPatches
	{
		[HarmonyPatch(typeof(MenuManager), "PageOpen")]
		[HarmonyPrefix]
		private static void OnPageOpen(MenuManager __instance, MenuPageIndex menuPageIndex)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			if ((int)menuPageIndex == 1)
			{
				VRSession.Instance?.HUD.PauseGame();
			}
		}

		[HarmonyPatch(typeof(MenuManager), "PageCloseAll")]
		[HarmonyPrefix]
		private static void OnAllPagesClose(MenuManager __instance)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			if (Object.op_Implicit((Object)(object)__instance.currentMenuPage) && (int)__instance.currentMenuPage.menuPageIndex == 1)
			{
				VRSession.Instance?.HUD.ResumeGame();
			}
		}

		[HarmonyPatch(typeof(MenuPageEsc), "ButtonEventContinue")]
		[HarmonyPrefix]
		private static void OnEscapeMenuClose()
		{
			VRSession.Instance?.HUD.ResumeGame();
		}

		[HarmonyPatch(typeof(MenuPageEsc), "ButtonEventSelfDestruct")]
		[HarmonyPrefix]
		private static void OnSelfDestruct()
		{
			VRSession.Instance?.HUD.ResumeGame();
		}

		[HarmonyPatch(typeof(GameDirector), "OutroStart")]
		[HarmonyPostfix]
		private static void OnStartOutro()
		{
			VRSession.Instance?.HUD.ResumeGame(instant: true);
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.Universal, null)]
	internal static class PlayerNamePrefixPatches
	{
		[CompilerGenerated]
		private sealed class <<LobbyMenuWarnHostNotVR>g__CheckHostHasVR|1_0>d : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MenuPageLobby lobby;

			private <>c__DisplayClass1_0 <>8__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <<LobbyMenuWarnHostNotVR>g__CheckHostHasVR|1_0>d(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass1_0();
					<>8__1.lobby = lobby;
					<>2__current = new Utils.WaitUntilTimeout(() => <LobbyMenuWarnHostNotVR>g__HostIsInVR|1_2(<>8__1.lobby), 1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!<LobbyMenuWarnHostNotVR>g__HostIsInVR|1_2(<>8__1.lobby))
					{
						Logger.LogWarning("Host does not have the VR mod, some features may not work in this lobby");
						MenuManager.instance.PagePopUp("Host missing VR mod", Color.yellow, "The host does not appear to have the VR mod installed.\n\nSome VR features may not work, or have degraded functionality.", "It is what it is", true);
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass1_0
		{
			public MenuPageLobby lobby;

			internal bool <LobbyMenuWarnHostNotVR>b__1()
			{
				return <LobbyMenuWarnHostNotVR>g__HostIsInVR|1_2(lobby);
			}
		}

		[HarmonyPatch(typeof(PlayerAvatar), "Awake")]
		[HarmonyPostfix]
		private static void InsertPrefixPhononPatch(PlayerAvatar __instance)
		{
			if (SemiFunc.IsMultiplayer() && __instance.isLocal)
			{
				Player localPlayer = PhotonNetwork.LocalPlayer;
				localPlayer.CustomProperties[(object)"VRPlayer"] = VRSession.InVR;
				localPlayer.SetCustomProperties(localPlayer.CustomProperties, (Hashtable)null, (WebFlags)null);
			}
		}

		[HarmonyPatch(typeof(MenuPageLobby), "Start")]
		[HarmonyPostfix]
		private static void LobbyMenuWarnHostNotVR(MenuPageLobby __instance)
		{
			if (!PhotonNetwork.IsMasterClient && VRSession.InVR)
			{
				((MonoBehaviour)__instance).StartCoroutine(CheckHostHasVR(__instance));
			}
			[IteratorStateMachine(typeof(<<LobbyMenuWarnHostNotVR>g__CheckHostHasVR|1_0>d))]
			static IEnumerator CheckHostHasVR(MenuPageLobby lobby)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <<LobbyMenuWarnHostNotVR>g__CheckHostHasVR|1_0>d(0)
				{
					lobby = lobby
				};
			}
		}

		[HarmonyPatch(typeof(MenuPageLobby), "Update")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void LobbyMenuShowPrefix(MenuPageLobby __instance)
		{
			foreach (MenuPlayerListed item in from entry in __instance.listObjects
				select entry.GetComponent<MenuPlayerListed>() into player
				where Object.op_Implicit((Object)(object)player.playerAvatar)
				select player)
			{
				try
				{
					bool flag = (bool)item.playerAvatar.photonView.Owner.CustomProperties[(object)"VRPlayer"];
					((TMP_Text)item.playerName).richText = true;
					((TMP_Text)item.playerName).text = (flag ? "<color=#ff7a00>[VR]</color> " : "") + "<noparse>" + item.playerAvatar.playerName + "</noparse>";
				}
				catch
				{
				}
			}
		}

		[CompilerGenerated]
		internal static bool <LobbyMenuWarnHostNotVR>g__HostIsInVR|1_2(MenuPageLobby lobby)
		{
			return lobby.lobbyPlayers.Any((PlayerAvatar player) => player.photonView.Owner.IsMasterClient && ((Dictionary<object, object>)(object)player.photonView.Owner.CustomProperties).ContainsKey((object)"VRPlayer"));
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class ResultScreenPatches
	{
		[HarmonyPatch(typeof(ResultScreenUI), "StateFadeIn")]
		[HarmonyPrefix]
		private static void InitializeScreenPatch(ResultScreenUI __instance)
		{
			if (__instance.stateImpulse)
			{
				((TMP_Text)__instance.skipText).spriteAsset = AssetCollection.TMPInputsSpriteAsset;
				LoadingUI.instance.ResetPosition();
			}
		}

		[HarmonyPatch(typeof(ResultScreenUI), "Update")]
		[HarmonyPostfix]
		private static void DisableTurningPatch(ResultScreenUI __instance)
		{
			if (!(__instance.fadeLerp < 1f))
			{
				PlayerController.instance.InputDisable(0.1f);
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class ScreenSpiralPatches
	{
		[HarmonyPatch(typeof(SpiralOnScreen), "Start")]
		[HarmonyPostfix]
		private static void OnSpiralCreate(SpiralOnScreen __instance)
		{
			GameObjectExtensions.SetLayerRecursively(((Component)__instance).gameObject, 5);
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class SplashScreenPatches
	{
		private static RectTransform logoTransform;

		[HarmonyPatch(typeof(SplashScreenUI), "Awake")]
		[HarmonyPostfix]
		private static void AddRepoXRLogoPatch(SplashScreenUI __instance)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("RepoXR Logo");
			val.transform.parent = ((Transform)__instance.semiworkTransform).parent;
			val.transform.localPosition = Vector3.zero;
			val.transform.localRotation = Quaternion.identity;
			val.transform.localScale = Vector3.one * 0.8f;
			val.AddComponent<Image>().sprite = AssetCollection.Logo;
			val.SetActive(false);
			logoTransform = val.GetComponent<RectTransform>();
			logoTransform.sizeDelta = new Vector2(530f, 155f) * 0.4f;
		}

		[HarmonyPatch(typeof(SplashScreen), "SemiworkAnimation")]
		[HarmonyPostfix]
		private static void LogoAnimationPatch(SplashScreen __instance)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			((Transform)logoTransform).localPosition = ((Transform)SplashScreenUI.instance.semiworkTransform).localPosition + Vector3.down * 80f;
		}

		[HarmonyPatch(typeof(SplashScreen), "Update")]
		[HarmonyPostfix]
		private static void SetFadeOverlayPatch(SplashScreen __instance)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			((Component)logoTransform).gameObject.SetActive(((Component)SplashScreenUI.instance.semiworkTransform).gameObject.activeSelf);
			((Graphic)FadeOverlay.Instance.Image).color = new Color(0f, 0f, 0f, 1f);
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class TutorialPatches
	{
		private static TMP_SpriteAsset originalEmojis;

		[HarmonyPatch(typeof(TutorialUI), "Start")]
		[HarmonyPostfix]
		private static void OnTutorialStart(TutorialUI __instance)
		{
			originalEmojis = ((TMP_Text)__instance.Text).spriteAsset;
			((TMP_Text)__instance.dummyText).spriteAsset = AssetCollection.TMPInputsSpriteAsset;
		}

		[HarmonyPatch(typeof(TutorialUI), "SetPage")]
		[HarmonyPrefix]
		private static void UpdateTextSpriteAtlas(TutorialUI __instance, ref string dummyTextString, bool transition)
		{
			((TMP_Text)__instance.Text).spriteAsset = (transition ? originalEmojis : AssetCollection.TMPInputsSpriteAsset);
			dummyTextString = dummyTextString.Replace("keyboard", "controller");
		}

		[HarmonyPatch(typeof(TutorialUI), "SetTipPage")]
		[HarmonyPrefix]
		private static void UpdateTipTextSpriteAtlas(TutorialUI __instance, ref string text)
		{
			((TMP_Text)__instance.Text).spriteAsset = AssetCollection.TMPInputsSpriteAsset;
			text = text.Replace("keyboard", "controller");
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> SwitchPagePatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected O, but got Unknown
			CodeInstruction[] array = (CodeInstruction[])(object)((!Plugin.GameDebugBuild) ? new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldloc_1, (object)null)
			} : new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(AccessTools.Inner(typeof(TutorialUI), "<SwitchPage>d__34"), "<>4__this"))
			});
			CodeMatcher obj = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertySetter(typeof(TMP_Text), "text"), (string)null)
			});
			CodeInstruction[] array2 = array;
			int num = 0;
			CodeInstruction[] array3 = (CodeInstruction[])(object)new CodeInstruction[1 + array2.Length];
			ReadOnlySpan<CodeInstruction> readOnlySpan = new ReadOnlySpan<CodeInstruction>(array2);
			readOnlySpan.CopyTo(new Span<CodeInstruction>(array3).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			array3[num] = new CodeInstruction(OpCodes.Call, (object)new Action<TutorialUI>(SetSpriteAtlas).Method);
			return obj.InsertAndAdvance(array3).InstructionEnumeration();
			static void SetSpriteAtlas(TutorialUI ui)
			{
				((TMP_Text)ui.Text).spriteAsset = AssetCollection.TMPInputsSpriteAsset;
			}
		}

		[HarmonyPatch(typeof(TutorialDirector), "Awake")]
		[HarmonyPostfix]
		private static void OnTutorialDirectorCreate(TutorialDirector __instance)
		{
			TutorialPage obj = __instance.tutorialPages[10];
			TutorialPage val = __instance.tutorialPages[11];
			TutorialPage val2 = __instance.tutorialPages[12];
			TutorialPage val3 = __instance.tutorialPages[25];
			obj.localizedText = Utils.L("TUTORIAL.INVENTORY_FILL.TEXT");
			obj.localizedDummyText = Utils.L("TUTORIAL.INVENTORY_FILL.DUMMY_TEXT");
			val.localizedText = Utils.L("TUTORIAL.INVENTORY_EMPTY.TEXT");
			val.localizedDummyText = Utils.L("TUTORIAL.INVENTORY_EMPTY.DUMMY_TEXT");
			val2.localizedText = Utils.L("TUTORIAL.MAP.TEXT");
			val2.localizedDummyText = Utils.L("TUTORIAL.MAP.DUMMY_TEXT");
			val3.localizedText = Utils.L("TUTORIAL.EXPRESSIONS.TEXT");
		}

		[HarmonyPatch(typeof(TutorialTruckTrigger), "Update")]
		[HarmonyPostfix]
		private static void TruckForceRotate(TutorialTruckTrigger __instance)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (!(__instance.lockLookTimer <= 0f))
			{
				VRCameraAim.instance.SetAimTarget(__instance.lookTarget.position + Vector3.down, 0.1f, 5f, ((Component)__instance).gameObject, 90, lowImpact: true);
			}
		}

		[HarmonyPatch(typeof(SpectateHeadUI), "Awake")]
		[HarmonyPostfix]
		private static void OnSpectateHeadUICreate(SpectateHeadUI __instance)
		{
			((TMP_Text)__instance.promptText).spriteAsset = AssetCollection.TMPInputsSpriteAsset;
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class UIPatches
	{
		[HarmonyPatch(typeof(MenuCursor), "Update")]
		[HarmonyPrefix]
		private static bool MenuCursorVRPatch(MenuCursor __instance)
		{
			((Component)__instance).gameObject.SetActive(false);
			return false;
		}

		[HarmonyPatch(typeof(MenuPageMain), "Start")]
		[HarmonyPostfix]
		private static void DisableMainMenuAnimation(MenuPageMain __instance)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			__instance.menuPage.disableIntroAnimation = true;
			__instance.doIntroAnimation = false;
			((Component)__instance).transform.localPosition = Vector3.zero;
			__instance.waitTimer = 3f;
			__instance.introDone = true;
		}

		[HarmonyPatch(typeof(SemiFunc), "UIMouseHover")]
		[HarmonyPrefix]
		private static bool DisableHoverOnEarly()
		{
			return XRRayInteractorManager.Instance != null;
		}

		[HarmonyPatch(typeof(SemiFunc), "UIMouseHover")]
		[HarmonyPrefix]
		private static bool UIPointerHoverOtherCanvasPatch(RectTransform rectTransform, ref bool __result)
		{
			XRRayInteractorManager instance = XRRayInteractorManager.Instance;
			if (instance == null)
			{
				return true;
			}
			RaycastResult val = default(RaycastResult);
			if (!instance.GetActiveInteractor().Item1.TryGetCurrentUIRaycastResult(ref val))
			{
				__result = false;
				return false;
			}
			if ((Object)(object)((RaycastResult)(ref val)).gameObject.GetComponentInParent<Canvas>() != (Object)(object)((Component)rectTransform).GetComponentInParent<Canvas>())
			{
				__result = false;
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(SemiFunc), "UIMouseHover")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UIPointerHoverPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Expected O, but got Unknown
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(SemiFunc), "UIMousePosToUIPos", (Type[])null, (Type[])null), (string)null)
			}).SetOperandAndAdvance((object)AccessTools.PropertyGetter(typeof(XRRayInteractorManager), "Instance")).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Ldarg_1, (object)null),
				new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(XRRayInteractorManager), "GetUIHitPosition", (Type[])null, (Type[])null))
			})
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(Transform), "position"), (string)null)
				})
				.SetOperandAndAdvance((object)AccessTools.PropertyGetter(typeof(Transform), "localPosition"))
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(RectTransformUtility), "RectangleContainsScreenPoint", new Type[3]
					{
						typeof(RectTransform),
						typeof(Vector2),
						typeof(Camera)
					}, (Type[])null), (string)null)
				})
				.SetOperandAndAdvance((object)new Func<RectTransform, Vector2, Camera, bool>(RectangleContainsCanvasPoint).Method)
				.SearchBack((Func<CodeInstruction, bool>)((CodeInstruction instr) => instr.opcode == OpCodes.Brfalse))
				.SetOpcodeAndAdvance(OpCodes.Br)
				.Advance(-1)
				.Insert((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Pop, (object)null)
				})
				.InstructionEnumeration();
			static bool RectangleContainsCanvasPoint(RectTransform viewport, Vector2 localPos, Camera _unused)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: 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)
				Vector3 val = ((Component)((Component)viewport).GetComponentInParent<Canvas>()).transform.TransformPoint(new Vector3(localPos.x, localPos.y, 0f));
				Vector3 val2 = ((Transform)viewport).InverseTransformPoint(val);
				Rect rect = viewport.rect;
				return ((Rect)(ref rect)).Contains(new Vector2(val2.x, val2.y));
			}
		}

		[HarmonyPatch(typeof(MenuManager), "Update")]
		[HarmonyPrefix]
		private static void UpdateMouseHoldPosition(MenuManager __instance)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//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)
			XRRayInteractorManager instance = XRRayInteractorManager.Instance;
			if (instance == null)
			{
				return;
			}
			if (instance.GetTriggerButton())
			{
				if (__instance.mouseHoldPosition == Vector2.zero)
				{
					__instance.mouseHoldPosition = instance.GetUIHitPosition(instance.GetUIHitRectTransform());
				}
			}
			else
			{
				__instance.mouseHoldPosition = Vector2.zero;
			}
		}

		[HarmonyPatch(typeof(SemiFunc), "UIMouseGetLocalPositionWithinRectTransform")]
		[HarmonyPrefix]
		private static bool UIMouseGetLocalPositionWithinRectTransformPatch(RectTransform rectTransform, ref Vector2 __result)
		{
			//IL_000d: 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_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_0078: 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)
			XRRayInteractorManager instance = XRRayInteractorManager.Instance;
			if (instance == null)
			{
				return true;
			}
			Vector2 uIHitPosition = instance.GetUIHitPosition(rectTransform);
			Vector2 val = SemiFunc.UIGetRectTransformPositionOnScreen(rectTransform, false);
			Rect rect = rectTransform.rect;
			float num = ((Rect)(ref rect)).width * rectTransform.pivot.x;
			rect = rectTransform.rect;
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(num, ((Rect)(ref rect)).height * rectTransform.pivot.y);
			__result = new Vector2(uIHitPosition.x - val.x, uIHitPosition.y - val.y) + val2;
			return false;
		}

		[HarmonyPatch(typeof(SemiFunc), "UIGetRectTransformPositionOnScreen")]
		[HarmonyPostfix]
		private static void UIGetRectTransformPositionOnCanvas(RectTransform rectTransform, ref Vector2 __result)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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)
			Vector3 val = ((Component)((Component)rectTransform).GetComponentInParent<MenuPage>()).transform.InverseTransformPoint(((Transform)rectTransform).position);
			Vector3 val2 = val;
			Rect rect = rectTransform.rect;
			float num = ((Rect)(ref rect)).width * rectTransform.pivot.x;
			rect = rectTransform.rect;
			val = val2 - new Vector3(num, ((Rect)(ref rect)).height * rectTransform.pivot.y, 0f);
			__result = Vector2.op_Implicit(val);
		}

		[HarmonyPatch(typeof(MenuManager), "PageOpen")]
		[HarmonyPostfix]
		private static void OnPageOpen(MenuPage __result)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((Component)__result).transform.localEulerAngles = Vector3.zero;
		}

		[HarmonyPatch(typeof(MenuSelectionBoxTop), "Update")]
		[HarmonyPostfix]
		private static void FixButtonOverlayPosition(MenuSelectionBoxTop __instance)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)MenuManager.instance.activeSelectionBox))
			{
				Vector3 localScale = ((Component)((Component)__instance).GetComponentInParent<Canvas>()).transform.localScale;
				Vector3 localScale2 = ((Component)((Component)MenuManager.instance.activeSelectionBox).GetComponentInParent<Canvas>()).transform.localScale;
				Vector3 localScale3 = default(Vector3);
				((Vector3)(ref localScale3))..ctor((localScale.x != 0f) ? (localScale2.x / localScale.x) : 0f, (localScale.y != 0f) ? (localScale2.y / localScale.y) : 0f, (localScale.z != 0f) ? (localScale2.z / localScale.z) : 0f);
				((Transform)__instance.rectTransform).position = ((Transform)MenuManager.instance.activeSelectionBox.rectTransform).position;
				((Transform)__instance.rectTransform).rotation = ((Transform)MenuManager.instance.activeSelectionBox.rectTransform).rotation;
				((Transform)__instance.rectTransform).parent.localScale = localScale3;
			}
		}

		[HarmonyPatch(typeof(MenuScrollBox), "Update")]
		[HarmonyPostfix]
		private static void HandleVRScrollLogic(MenuScrollBox __instance)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: 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_00b8: 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_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: 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_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			XRRayInteractorManager instance = XRRayInteractorManager.Instance;
			if (!__instance.scrollBar.activeSelf || !__instance.scrollBoxActive || (Object)(object)instance == (Object)null)
			{
				return;
			}
			Rect rect;
			if (instance.GetTriggerButton() && SemiFunc.UIMouseHover(__instance.parentPage, __instance.scrollBarBackground, __instance.menuSelectableElement.menuID, 0f, 0f, (MenuScrollBox)null, (ScrollRect)null))
			{
				float num = SemiFunc.UIMouseGetLocalPositionWithinRectTransform(__instance.scrollBarBackground).y;
				if (num < __instance.scrollHandle.sizeDelta.y / 2f)
				{
					num = __instance.scrollHandle.sizeDelta.y / 2f;
				}
				float num2 = num;
				rect = __instance.scrollBarBackground.rect;
				if (num2 > ((Rect)(ref rect)).height - __instance.scrollHandle.sizeDelta.y / 2f)
				{
					rect = __instance.scrollBarBackground.rect;
					num = ((Rect)(ref rect)).height - __instance.scrollHandle.sizeDelta.y / 2f;
				}
				__instance.scrollHandleTargetPosition = num;
			}
			if (instance.GetUIScrollY() != 0f && SemiFunc.NoTextInputsActive())
			{
				__instance.scrollHandleTargetPosition += instance.GetUIScrollY() * 20f / (__instance.scrollHeight * 0.01f);
				if (__instance.scrollHandleTargetPosition < __instance.scrollHandle.sizeDelta.y / 2f)
				{
					__instance.scrollHandleTargetPosition = __instance.scrollHandle.sizeDelta.y / 2f;
				}
				float scrollHandleTargetPosition = __instance.scrollHandleTargetPosition;
				rect = __instance.scrollBarBackground.rect;
				if (scrollHandleTargetPosition > ((Rect)(ref rect)).height - __instance.scrollHandle.sizeDelta.y / 2f)
				{
					rect = __instance.scrollBarBackground.rect;
					__instance.scrollHandleTargetPosition = ((Rect)(ref rect)).height - __instance.scrollHandle.sizeDelta.y / 2f;
				}
			}
		}

		[HarmonyPatch(typeof(MenuScrollBox), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ScrollDisableInputs(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(SemiFunc), "InputMovementY", (Type[])null, (Type[])null), (string)null)
			}).Set(OpCodes.Ldc_R4, (object)0f).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(SemiFunc), "InputScrollY", (Type[])null, (Type[])null), (string)null)
			})
				.Set(OpCodes.Ldc_R4, (object)0f)
				.InstructionEnumeration();
		}

		[HarmonyPatch(typeof(MenuPageSettingsControls), "Start")]
		[HarmonyPostfix]
		private static void OnControlsPageOpened(MenuPageSettingsControls __instance)
		{
			((Component)__instance).gameObject.AddComponent<RebindManager>();
		}

		[HarmonyPatch(typeof(MenuElementSaveFile), "Update")]
		[HarmonyPostfix]
		private static void OnSaveFilePressed(MenuElementSaveFile __instance)
		{
			XRRayInteractorManager instance = XRRayInteractorManager.Instance;
			if (__instance.menuElementHover.isHovering && !((Object)(object)instance == (Object)null) && !SemiFunc.InputDown((InputKey)9) && !SemiFunc.InputDown((InputKey)10) && instance.GetTriggerDown())
			{
				MenuManager.instance.MenuEffectClick((MenuClickEffectType)1, (MenuPage)null, -1f, -1f, false);
				__instance.parentPageSaves.SaveFileSelected(__instance.saveFileName, __instance.saveFileBackups);
			}
		}

		[HarmonyPatch(typeof(SemiFunc), "UIHideTumble")]
		[HarmonyPostfix]
		private static void HideCustomCameraTumble()
		{
			CustomTumbleUI? instance = CustomTumbleUI.instance;
			if (instance != null)
			{
				((TumbleUI)instance).Hide();
			}
		}

		[HarmonyPatch(typeof(PlayerTumble), "OverrideTumbleUIDisable")]
		[HarmonyPostfix]
		private static void OverrideCustomTumbleUI(PlayerTumble __instance, float _time)
		{
			if (__instance.playerAvatar.isLocal)
			{
				CustomTumbleUI? instance = CustomTumbleUI.instance;
				if (instance != null)
				{
					((TumbleUI)instance).HideOverride(_time);
				}
			}
		}

		[HarmonyPatch(typeof(MenuLoadingGraphics), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> MenuGraphicsRotationFix(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertySetter(typeof(Transform), "eulerAngles"), (string)null)
			}).SetOperandAndAdvance((object)AccessTools.PropertySetter(typeof(Transform), "localEulerAngles")).InstructionEnumeration();
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> FixRegionUIPositioning(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_002b: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)32f, (string)null)
			}).SetOperandAndAdvance((object)1f).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(MenuSelectionBoxTop), "Start")]
		[HarmonyPostfix]
		private static void DisableRaycastSelectionBox(MenuSelectionBoxTop __instance)
		{
			((Graphic)((Component)__instance).GetComponentInChildren<RawImage>()).raycastTarget = false;
		}

		[HarmonyPatch(typeof(MenuKeybind), "OnDestroy")]
		[HarmonyPrefix]
		private static bool KeybindSuppressError(MenuKeybind __instance)
		{
			return (Object)(object)__instance.menuBigButton != (Object)null;
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class ValuableDiscoverPatches
	{
		[HarmonyPatch(typeof(ValuableDiscover), "New")]
		[HarmonyPrefix]
		private static bool OnValuableDiscovered(ValuableDiscover __instance, PhysGrabObject _target, State _state)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Invalid comparison between Unknown and I4
			ValuableDiscoverGraphic component = Object.Instantiate<GameObject>(AssetCollection.ValuableDiscover).GetComponent<ValuableDiscoverGraphic>();
			component.target = _target;
			if (Compat.IsLoaded("Kistras-CustomDiscoverStateLib") && AttemptSetupCustom(component, __instance, _target, _state))
			{
				return false;
			}
			if ((int)_state == 1)
			{
				component.ReminderSetup();
			}
			if ((int)_state == 2)
			{
				component.BadSetup();
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static bool AttemptSetupCustom(ValuableDiscoverGraphic graphic, ValuableDiscover valuable, PhysGrabObject target, State state)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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_006c: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			if (CustomDiscoverState.customStates.TryGetValue(state, out var value))
			{
				graphic.CustomSetup(state, value.ColorMiddle, value.ColorCorner);
				return true;
			}
			State key;
			foreach (KeyValuePair<State, ConditionalStateDelegate> conditionalState in CustomDiscoverState.conditionalStates)
			{
				conditionalState.Deconstruct(out key, out var value2);
				State val = key;
				if (value2.Invoke(valuable, target) && CustomDiscoverState.customStates[val] != null)
				{
					value = CustomDiscoverState.customStates[val];
					graphic.CustomSetup(val, value.ColorMiddle, value.ColorCorner);
					return true;
				}
			}
			Color? val2 = default(Color?);
			Color? val3 = default(Color?);
			foreach (KeyValuePair<State, DynamicStateDelegate> dynamicState in CustomDiscoverState.dynamicStates)
			{
				dynamicState.Deconstruct(out key, out var value3);
				State newState = key;
				if (value3.Invoke(valuable, target, ref val2, ref val3))
				{
					graphic.CustomSetup(newState, val2.Value, val3.Value);
					return true;
				}
			}
			return false;
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class WorldSpaceUIParentPatches
	{
		[HarmonyPatch(typeof(WorldSpaceUIChild), "SetPosition")]
		[HarmonyPrefix]
		private static bool SetPositionPatch(WorldSpaceUIChild __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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)
			Vector3 val = __instance.worldPosition + __instance.positionOffset;
			Vector3 val2 = val - ((Component)AssetManager.instance.mainCamera).transform.position;
			Vector3 normalized = ((Vector3)(ref val2)).normalized;
			float num = Vector3.Distance(val, ((Component)Camera.main).transform.position);
			((Transform)__instance.myRect).position = val;
			((Transform)__instance.myRect).rotation = Quaternion.LookRotation(normalized, Vector3.up);
			((Transform)__instance.myRect).localScale = Vector3.one * Mathf.Lerp(1f, 10f, Mathf.InverseLerp(3f, 20f, num));
			return false;
		}
	}
}
namespace RepoXR.Patches.Rendering
{
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class PostProcessPatches
	{
		[HarmonyPatch(typeof(PostProcessing), "Awake")]
		[HarmonyPostfix]
		private static void OnPostProcessCreated(PostProcessing __instance)
		{
			((Component)__instance).gameObject.AddComponent<CustomPostProcessing>();
		}

		[HarmonyPatch(typeof(SemiFunc), "BlindingLightBloomEffect")]
		[HarmonyPrefix]
		private static bool BlindingLightBloomVR(Transform _source, GameObject _obj)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: 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_012b: 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_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.Photosensitivity())
			{
				return false;
			}
			if (Vector3.Distance(_source.position, ((Component)PlayerController.instance.playerAvatarScript).transform.position) > 6f)
			{
				return false;
			}
			if (!SemiFunc.OnScreen(_source.position, 0f, 0.333f))
			{
				return false;
			}
			Vector3 val = CameraUtils.Instance.MainCamera.WorldToScreenPoint(_source.position);
			if (val.z < 0f)
			{
				return false;
			}
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor((float)XRSettings.eyeTextureWidth * 0.5f, (float)XRSettings.eyeTextureHeight * 0.5f);
			float num = Vector2.Distance(new Vector2(val.x, val.y), val2);
			float num2 = Mathf.Sqrt(val2.x * val2.x + val2.y * val2.y);
			float num3 = Mathf.Clamp01(1f - num / num2);
			float num4 = Vector3.Distance(((Component)CameraUtils.Instance.MainCamera).transform.position, _source.position);
			float num5 = Mathf.Clamp01(1f - (num4 - 1f) / 10f);
			Vector3 val3 = ((Component)CameraUtils.Instance.MainCamera).transform.position - _source.position;
			Vector3 normalized = ((Vector3)(ref val3)).normalized;
			float num6 = Vector3.Dot(_source.forward, normalized);
			float num7 = Mathf.Clamp01(Mathf.InverseLerp(0.8f, 1f, num6));
			float num8 = num3 * num5 * num7;
			if (num8 <= 0f)
			{
				return false;
			}
			float num9 = Mathf.Lerp(10f, 30f, num8);
			float num10 = Mathf.Lerp(0.9f, 0.15f, num8);
			PostProcessing.Instance.BloomOverride(num9, num10, 20f, 10f, 0.1f, _obj);
			return false;
		}
	}
}
namespace RepoXR.Patches.Player
{
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class CosmeticPatches
	{
		[HarmonyPatch(typeof(CosmeticShopMachine), "InteractingPlayerLogic")]
		[HarmonyPostfix]
		private static void LookAtMachinePatch(CosmeticShopMachine __instance)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Invalid comparison between Unknown and I4
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)__instance.interactingPlayer) && !__instance.interactingPlayerStuck && __instance.interactingPlayer.isLocal && (int)__instance.stateCurrent == 4)
			{
				VRCameraAim.instance.SetAimTarget(__instance.playerCameraTarget.position, 0.5f, 5f, ((Component)__instance).gameObject, 50, lowImpact: true);
			}
		}

		[HarmonyPatch(typeof(CosmeticTokenUIElement), "OnDestroy")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> TokenScalePatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.PropertyGetter(typeof(Quaternion), "identity"), (string)null)
			}).Advance(-2).RemoveInstructions(3)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Call, (object)AccessTools.PropertyGetter(typeof(Component), "transform")),
					new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(Transform), "parent"))
				})
				.SetOperandAndAdvance((object)AccessTools.Method(typeof(GameObject), "Instantiate", new Type[2]
				{
					typeof(GameObject),
					typeof(Transform)
				}, (Type[])null))
				.InstructionEnumeration();
		}

		[HarmonyPatch(typeof(PlayerCosmetics), "SetupCosmeticsLogic")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> InstantiateCosmeticVRPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(true, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(PlayerCosmetics), "InstantiateCosmetic", (Type[])null, (Type[])null), (string)null)
			}).Advance(1).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[5]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldloc_S, (object)(Plugin.GameDebugBuild ? 24 : 14)),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(AccessTools.Inner(typeof(PlayerCosmetics), "<>c__DisplayClass57_0"), "_cosmeticAsset")),
				new CodeInstruction(OpCodes.Ldloc_1, (object)null),
				new CodeInstruction(OpCodes.Call, (object)new Action<PlayerCosmetics, CosmeticAsset, List<Cosmetic>>(InstantiateCosmeticVR).Method)
			})
				.InstructionEnumeration();
		}

		private static void InstantiateCosmeticVR(PlayerCosmetics cosmetics, CosmeticAsset cosmeticAsset, List<Cosmetic> newEquipped)
		{
			//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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Invalid comparison between Unknown and I4
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Invalid comparison between Unknown and I4
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Invalid comparison between Unknown and I4
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Invalid comparison between Unknown and I4
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Invalid comparison between Unknown and I4
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Invalid comparison between Unknown and I4
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Invalid comparison between Unknown and I4
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected I4, but got Unknown
			//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_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Expected O, but got Unknown
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			CosmeticAsset cosmeticAsset2 = cosmeticAsset;
			if (!Object.op_Implicit((Object)(object)cosmeticAsset2) || !cosmeticAsset2.prefab.IsValid())
			{
				return;
			}
			PlayerAvatarVisuals playerAvatarVisuals = cosmetics.playerAvatarVisuals;
			bool flag;
			if (playerAvatarVisuals != null)
			{
				PlayerAvatar playerAvatar = playerAvatarVisuals.playerAvatar;
				if ((playerAvatar != null && !playerAvatar.isLocal) || playerAvatarVisuals.isMenuAvatar)
				{
					flag = true;
					goto IL_0060;
				}
			}
			flag = false;
			goto IL_0060;
			IL_00db:
			VRSession instance;
			Transform val = ((Component)instance.Player.Rig.rightArmMesh).transform;
			goto IL_00f7;
			IL_0060:
			if (flag)
			{
				return;
			}
			instance = VRSession.Instance;
			if (instance == null)
			{
				return;
			}
			CosmeticParent val2 = cosmetics.cosmeticParents.Find((CosmeticParent x) => x.cosmeticType == cosmeticAsset2.type);
			if (val2 == null)
			{
				return;
			}
			CosmeticType type = cosmeticAsset2.type;
			if ((int)type <= 9)
			{
				if ((int)type != 1)
				{
					if ((int)type == 2)
					{
						goto IL_00c2;
					}
					if ((int)type != 9)
					{
						goto IL_00f4;
					}
				}
				goto IL_00db;
			}
			if ((int)type != 10)
			{
				if ((int)type == 26)
				{
					goto IL_00db;
				}
				if ((int)type != 27)
				{
					goto IL_00f4;
				}
			}
			goto IL_00c2;
			IL_00f4:
			val = null;
			goto IL_00f7;
			IL_00c2:
			val = ((Component)instance.Player.Rig.leftArmMesh).transform;
			goto IL_00f7;
			IL_00f7:
			Transform val3 = val;
			if (!((Object)(object)val3 == (Object)null))
			{
				GameObject val4 = Object.Instantiate<GameObject>(cosmeticAsset2.prefab.Prefab, val3.parent);
				Cosmetic component = val4.GetComponent<Cosmetic>();
				component.cosmeticAsset = cosmeticAsset2;
				component.cosmeticTypeAsset = MetaManager.instance.cosmeticTypeAssets[(int)cosmeticAsset2.type];
				component.playerCosmetics = cosmetics;
				component.cosmeticParent = new CosmeticParent
				{
					parent = val3.parent,
					cosmeticType = cosmeticAsset2.type,
					resetTransform = val2.resetTransform,
					springImpulse = val2.springImpulse,
					baseMeshes = new List<Transform>(1) { val3 },
					baseMeshParents = new List<Transform>(1) { val3.parent }
				};
				component.type = cosmeticAsset2.type;
				component.rarity = cosmeticAsset2.rarity;
				if (val2.resetTransform)
				{
					val4.transform.localPosition = Vector3.zero;
					val4.transform.localRotation = Quaternion.identity;
					val4.transform.localScale = Vector3.one;
				}
				GameObjectExtensions.SetLayerRecursively(val4, 6);
				component.Setup();
				CollectionExtensions.Do<Collider>((IEnumerable<Collider>)val4.GetComponentsInChildren<Collider>(true), (Action<Collider>)delegate(Collider collider)
				{
					collider.enabled = false;
				});
				CollectionExtensions.Do<MeshRenderer>((IEnumerable<MeshRenderer>)val4.GetComponentsInChildren<MeshRenderer>(true), (Action<MeshRenderer>)delegate(MeshRenderer renderer)
				{
					((Renderer)renderer).shadowCastingMode = (ShadowCastingMode)0;
				});
				newEquipped.Add(component);
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class CrouchPatches
	{
		[HarmonyPatch(typeof(CameraCrouchPosition), "Update")]
		[HarmonyPostfix]
		private static void CrouchPositionPatch(CameraCrouchPosition __instance)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			VRSession instance = VRSession.Instance;
			if (instance != null && instance.Player.physicalCrouch)
			{
				((Component)__instance).transform.localPosition = Vector3.zero;
			}
		}

		[HarmonyPatch(typeof(PlayerController), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> KeepCrouchTogglePatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(PlayerAvatar), "isTumbling"), (string)null)
			}).MatchBack(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Stfld, (object)AccessTools.Field(typeof(PlayerController), "toggleCrouch"), (string)null)
			}).Advance(-1)
				.RemoveInstruction()
				.Insert((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)new Func<bool>(IsRoomscaleCrouching).Method)
				})
				.InstructionEnumeration();
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			static bool IsRoomscaleCrouching()
			{
				VRSession instance = VRSession.Instance;
				if (instance != null)
				{
					VRPlayer player = instance.Player;
					if (player != null)
					{
						return player.physicalCrouch;
					}
				}
				return false;
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class ExpressionPatches
	{
		[HarmonyPatch(typeof(PlayerExpression), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> RadialSelectionPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(SemiFunc), "InputHold", (Type[])null, (Type[])null), (string)null)
			}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher matcher)
			{
				matcher.SetOperandAndAdvance((object)AccessTools.Method(typeof(ExpressionRadial), "ExpressionActive", (Type[])null, (Type[])null));
			}, (Action<string>)null).InstructionEnumeration();
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class FlashlightPatches
	{
		[HarmonyPatch(typeof(FlashlightController), "Start")]
		[HarmonyPrefix]
		private static void OnFlashlightStart(FlashlightController __instance)
		{
			if (__instance.PlayerAvatar.IsVRPlayer())
			{
				((Behaviour)__instance.toolBackAway).enabled = false;
				((Behaviour)((Component)__instance).GetComponentInChildren<FlashlightBob>()).enabled = false;
				((Behaviour)((Component)__instance).GetComponentInChildren<FlashlightSprint>()).enabled = false;
				((Behaviour)((Component)__instance).GetComponentInChildren<FlashlightTilt>()).enabled = false;
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.Universal, null)]
	internal static class UniversalFlashlightPatches
	{
		[HarmonyPatch(typeof(FlashlightController), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DisableFlashlightMovement(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(PlayerAvatar), "isLocal"), (string)null)
			}).SetInstruction(new CodeInstruction(OpCodes.Call, (object)new Func<PlayerAvatar, bool>(IsVRPlayerOrLocal).Method)).InstructionEnumeration();
			static bool IsVRPlayerOrLocal(PlayerAvatar player)
			{
				if (!player.isLocal)
				{
					return player.IsVRPlayer();
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(FlashlightLightAim), "Update")]
		[HarmonyPostfix]
		private static void OnFlashlightAim(FlashlightLightAim __instance)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.playerAvatar.IsVRPlayer())
			{
				((Behaviour)__instance).enabled = false;
				((Component)__instance).transform.localRotation = Quaternion.identity;
				((Component)__instance).transform.parent.localRotation = Quaternion.identity;
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class InventoryPatches
	{
		private static bool ItemIsMine(ItemEquippable item)
		{
			if (SemiFunc.IsMultiplayer())
			{
				return item.ownerPlayerId == PlayerAvatar.instance.photonView.ViewID;
			}
			return true;
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> MinimumScaleEquip(IEnumerable<CodeInstruction> instructions)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Expected O, but got Unknown
			CodeInstruction[] array = (CodeInstruction[])(object)((!Plugin.GameDebugBuild) ? new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldloc_1, (object)null)
			} : new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(AccessTools.Inner(typeof(ItemEquippable), "<AnimateEquip>d__55"), "<>4__this"))
			});
			CodeMatcher obj = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)0.01f, (string)null)
			}).Advance(-2).RemoveInstructions(4);
			CodeInstruction[] array2 = array;
			int num = 0;
			CodeInstruction[] array3 = (CodeInstruction[])(object)new CodeInstruction[1 + array2.Length];
			ReadOnlySpan<CodeInstruction> readOnlySpan = new ReadOnlySpan<CodeInstruction>(array2);
			readOnlySpan.CopyTo(new Span<CodeInstruction>(array3).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			array3[num] = new CodeInstruction(OpCodes.Call, (object)new Func<ItemEquippable, Vector3>(MinimumScale).Method);
			return obj.Insert(array3).InstructionEnumeration();
			static Vector3 MinimumScale(ItemEquippable item)
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				if (!ItemIsMine(item))
				{
					return ((Component)item).transform.localScale * 0.01f;
				}
				return Vector3.one * 0.1667f;
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UnequipGrabImmediately(IEnumerable<CodeInstruction> instructions)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Expected O, but got Unknown
			CodeInstruction[] array = (CodeInstruction[])(object)((!Plugin.GameDebugBuild) ? new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldloc_1, (object)null)
			} : new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(AccessTools.Inner(typeof(ItemEquippable), "<AnimateUnequip>d__53"), "<>4__this"))
			});
			CodeMatcher obj = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertySetter(typeof(Transform), "localScale"), (string)null)
			}).Advance(1);
			CodeInstruction[] array2 = array;
			int num = 0;
			CodeInstruction[] array3 = (CodeInstruction[])(object)new CodeInstruction[1 + array2.Length];
			ReadOnlySpan<CodeInstruction> readOnlySpan = new ReadOnlySpan<CodeInstruction>(array2);
			readOnlySpan.CopyTo(new Span<CodeInstruction>(array3).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			array3[num] = new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(ItemEquippable), "ForceGrab", (Type[])null, (Type[])null));
			return obj.Insert(array3).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(ItemEquippable), "StateEquipped")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> StateEquippedPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_002b: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)0.1f, (string)null)
			}).SetInstructionAndAdvance(new CodeInstruction(OpCodes.Ldarg_0, (object)null)).Insert((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Call, (object)new Func<ItemEquippable, float>(MinimumMagnitude).Method)
			})
				.InstructionEnumeration();
			static float MinimumMagnitude(ItemEquippable item)
			{
				if (!ItemIsMine(item))
				{
					return 0.1f;
				}
				return 0.9f;
			}
		}

		[HarmonyPatch(typeof(ItemEquippable), "RayHitTestNew")]
		[HarmonyPrefix]
		private static bool ItemUnequipNoTeleport(ItemEquippable __instance, float distance)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: 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_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			VRSession instance = VRSession.Instance;
			if (instance == null)
			{
				return true;
			}
			if (instance.Player.Rig.inventoryController.visualsTransform.position.y < ((Component)PlayerAvatar.instance).transform.position.y + 0.1f)
			{
				int num = LayerMask.op_Implicit(SemiFunc.LayerMaskGetVisionObstruct()) & ~LayerMask.GetMask(new string[2] { "Ignore Raycast", "CollisionCheck" });
				RaycastHit val = default(RaycastHit);
				if (Physics.Raycast(((Component)Camera.main).transform.position, ((Component)Camera.main).transform.forward, ref val, distance, num))
				{
					__instance.teleportPosition = ((RaycastHit)(ref val)).point;
					return false;
				}
				__instance.teleportPosition = ((Component)Camera.main).transform.position + ((Component)Camera.main).transform.forward * 0.2f;
			}
			__instance.teleportPosition = ((Component)__instance).transform.position;
			return false;
		}

		[HarmonyPatch(typeof(PhysGrabObject), "OverrideTimersTick")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DisableItemHiding(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(AssetManager), "physDisabledPosition"), (string)null)
			}).Advance(-1).SetOpcodeAndAdvance(OpCodes.Ldarg_0)
				.SetAndAdvance(OpCodes.Call, (object)new Func<PhysGrabObject, Vector3>(GetTeleportLocation).Method)
				.InstructionEnumeration();
			static Vector3 GetTeleportLocation(PhysGrabObject @object)
			{
				//IL_0017: 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)
				ItemEquippable item = default(ItemEquippable);
				if (!((Component)@object).TryGetComponent<ItemEquippable>(ref item) || !ItemIsMine(item))
				{
					return AssetManager.instance.physDisabledPosition;
				}
				return ((Component)@object).transform.position;
			}
		}

		[HarmonyPatch(typeof(PhysGrabObject), "OverrideDeactivate")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DisableItemOverrideHiding(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(SemiFunc), "IsMasterClientOrSingleplayer", (Type[])null, (Type[])null), (string)null)
			}).Set(OpCodes.Call, (object)new Func<PhysGrabObject, bool>(ShouldMoveItem).Method).Insert((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null)
			})
				.InstructionEnumeration();
			static bool ShouldMoveItem(PhysGrabObject @object)
			{
				bool flag = SemiFunc.IsMasterClientOrSingleplayer();
				ItemEquippable item = default(ItemEquippable);
				if (!((Component)@object).TryGetComponent<ItemEquippable>(ref item))
				{
					return flag;
				}
				if (flag)
				{
					return !ItemIsMine(item);
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(InventorySpot), "EquipItem")]
		[HarmonyPrefix]
		private static void OnItemEquip(InventorySpot __instance, ItemEquippable item)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if ((int)__instance.currentState == 0)
			{
				VRSession.Instance.Player.Rig.inventoryController.EquipItem(item);
			}
		}

		[HarmonyPatch(typeof(InventorySpot), "UnequipItem")]
		[HarmonyPrefix]
		private static void OnItemUnequip(InventorySpot __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)__instance.currentState == 1)
			{
				VRSession.Instance?.Player.Rig.inventoryController.UnequipItem(__instance.CurrentItem);
			}
		}

		[HarmonyPatch(typeof(ItemBattery), "OverrideBatteryShow")]
		[HarmonyPrefix]
		private static bool HideBatteryIfEquipped(ItemBattery __instance)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			if (!Object.op_Implicit((Object)(object)__instance) || !Object.op_Implicit((Object)(object)__instance.itemEquippable))
			{
				return true;
			}
			return (int)__instance.itemEquippable.currentState != 2;
		}

		[HarmonyPatch(typeof(ItemEquippable), "RPC_SendPing")]
		[HarmonyPostfix]
		private static void OnInventoryPing(ItemEquippable __instance, float amount, float frequency, float time)
		{
			if ((!SemiFunc.IsMultiplayer() || PhysGrabber.instance.photonView.ViewID == __instance.ownerPlayerId) && __instance.inventorySpotIndex != -1)
			{
				VRSession.Instance.Player.Rig.inventoryController.PingSlot(__instance.inventorySpotIndex, amount, frequency, time);
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.Universal, null)]
	internal static class UniversalInventoryPatches
	{
		[HarmonyPatch(typeof(ItemMelee), "FixedUpdate")]
		[HarmonyPrefix]
		private static bool DontMeleeWhenEquipped(ItemMelee __instance)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			ItemState currentState = __instance.itemEquippable.currentState;
			if (currentState - 1 > 1)
			{
				return true;
			}
			return (!SemiFunc.IsMultiplayer() || !((Component)PhotonView.Find(__instance.itemEquippable.ownerPlayerId)).GetComponent<PlayerAvatar>().IsVRPlayer()) && (SemiFunc.IsMultiplayer() || !VRSession.InVR);
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class MapToolPatches
	{
		internal const float MAP_HOLD_ANGLE = 300f;

		[HarmonyPatch(typeof(MapToolController), "Start")]
		[HarmonyPostfix]
		private static void OnMapToolCreated(MapToolController __instance)
		{
			VRMapTool.Create();
		}

		[HarmonyPatch(typeof(MapToolController), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> MapToolDisableInput(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0027: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).Start().MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldloc_0, (object)null, (string)null)
			}).Set(OpCodes.Ldc_I4_0, (object)null)
				.InstructionEnumeration();
		}

		[HarmonyPatch(typeof(MapToolController), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> MapToolScalePatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Expected O, but got Unknown
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Expected O, but got Unknown
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected O, but got Unknown
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(MapToolController), "IntroCurve"), (string)null)
			}).Advance(-3).SetInstructionAndAdvance(new CodeInstruction(OpCodes.Ldarg_0, (object)null))
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)new Func<MapToolController, float>(GetMaximumScale).Method)
				})
				.SetInstructionAndAdvance(new CodeInstruction(OpCodes.Ldarg_0, (object)null))
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)new Func<MapToolController, float>(GetMinimumScale).Method)
				})
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(MapToolController), "OutroCurve"), (string)null)
				})
				.Advance(-3)
				.SetInstructionAndAdvance(new CodeInstruction(OpCodes.Ldarg_0, (object)null))
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)new Func<MapToolController, float>(GetMaximumScale).Method)
				})
				.SetInstructionAndAdvance(new CodeInstruction(OpCodes.Ldarg_0, (object)null))
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)new Func<MapToolController, float>(GetMinimumScale).Method)
				})
				.InstructionEnumeration();
			static float GetMaximumScale(MapToolController controller)
			{
				if (!controller.PlayerAvatar.isLocal || SemiFunc.MenuLevel())
				{
					return 1f;
				}
				return 0.75f;
			}
			static float GetMinimumScale(MapToolController controller)
			{
				if (!controller.PlayerAvatar.isLocal || SemiFunc.MenuLevel())
				{
					return 0f;
				}
				return 0.25f;
			}
		}

		[HarmonyPatch(typeof(MapToolController), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> MapToolVisibilityPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(MapToolController), "VisualTransform"), (string)null)
			}).Advance(3).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Call, (object)new Func<bool, MapToolController, bool>(FuckYouSpraty).Method)
			})
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(MapToolController), "VisualTransform"), (string)null)
				})
				.Advance(3)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Call, (object)new Func<bool, MapToolController, bool>(FuckYouSpraty).Method)
				})
				.InstructionEnumeration();
			static bool FuckYouSpraty(bool original, MapToolController controller)
			{
				return controller.PlayerAvatar.isLocal || original;
			}
		}

		[HarmonyPatch(typeof(MapToolController), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> NoShakePatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(CameraShake), "Shake", (Type[])null, (Type[])null), (string)null)
			}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher matcher)
			{
				matcher.Advance(-4).SetOpcodeAndAdvance(OpCodes.Nop).RemoveInstructions(4);
			}, (Action<string>)null).InstructionEnumeration();
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.Universal, null)]
	internal static class UniversalMapToolPatches
	{
		[HarmonyPatch(typeof(MapToolController), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> MapToolTransformPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Expected O, but got Unknown
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Expected O, but got Unknown
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Expected O, but got Unknown
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Expected O, but got Unknown
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Expected O, but got Unknown
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Expected O, but got Unknown
			CodeInstruction val = new CodeInstruction(OpCodes.Call, (object)new Func<bool, PhotonView, bool>(IsLocalOrVRPlayer).Method);
			CodeMatch val2 = new CodeMatch((OpCode?)OpCodes.Ldloc_0, (object)null, (string)null);
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)90f, (string)null)
			}).SetAndAdvance(OpCodes.Ldarg_0, (object)null).Insert((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Call, (object)new Func<MapToolController, float>(GetHoldAngle).Method)
			})
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1] { val2 })
				.SetAndAdvance(OpCodes.Ldloc_0, (object)null)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[3]
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(MapToolController), "photonView")),
					val
				})
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1] { val2 })
				.SetAndAdvance(OpCodes.Ldloc_0, (object)null)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[3]
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(MapToolController), "photonView")),
					val
				})
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(MapToolController), "FollowTransformClient"), (string)null)
				})
				.MatchBack(false, (CodeMatch[])(object)new CodeMatch[1] { val2 })
				.SetAndAdvance(OpCodes.Ldloc_0, (object)null)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[3]
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(MapToolController), "photonView")),
					val
				})
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.PropertyGetter(typeof(Vector3), "zero"), (string)null)
				})
				.Advance(-2)
				.SetAndAdvance(OpCodes.Call, (object)new Action<MapToolController>(ConditionalResetTransform).Method)
				.RemoveInstructions(Plugin.GameDebugBuild ? 14 : 12)
				.InstructionEnumeration();
			static void ConditionalResetTransform(MapToolController controller)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				if (!VRSession.InVR)
				{
					((Component)controller).transform.parent.localPosition = Vector3.zero;
					((Component)controller).transform.parent.localRotation = Quaternion.identity;
					controller.mainSpringTransform.localRotation = Quaternion.identity;
				}
			}
			static float GetHoldAngle(MapToolController mapTool)
			{
				if (mapTool.PlayerAvatar.isLocal && VRSession.InVR)
				{
					return 300f;
				}
				if (!mapTool.PlayerAvatar.isLocal && NetworkSystem.instance.IsVRPlayer(mapTool.PlayerAvatar))
				{
					return 300f;
				}
				return 90f;
			}
			static bool IsLocalOrVRPlayer(bool isLocal, PhotonView view)
			{
				if (!isLocal)
				{
					return NetworkSystem.instance.IsVRView(view);
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(MapToolController), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> MapToolAnimationPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Quaternion), "Euler", new Type[3]
				{
					typeof(float),
					typeof(float),
					typeof(float)
				}, (Type[])null), (string)null)
			}).Advance(4).SetInstruction(new CodeInstruction(OpCodes.Call, (object)new Func<MapToolController, float>(GetIntroLerp).Method))
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(MapToolController), "OutroCurve"), (string)null)
				})
				.Advance(6)
				.Insert((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Call, (object)new Action<MapToolController>(OutroAnimation).Method)
				})
				.InstructionEnumeration();
			static float GetIntroLerp(MapToolController controller)
			{
				if (!controller.PlayerAvatar.IsVRPlayer())
				{
					return controller.HideLerp;
				}
				return 1f - controller.HideLerp;
			}
			static void OutroAnimation(MapToolController controller)
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				if (controller.PlayerAvatar.IsVRPlayer())
				{
					controller.HideTransform.localRotation = Quaternion.Slerp(Quaternion.Euler(300f, 0f, 0f), Quaternion.identity, controller.OutroCurve.Evaluate(controller.HideLerp));
				}
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class PlayerAvatarPatches
	{
		[HarmonyPatch(typeof(PlayerAvatar), "PlayerDeathDone")]
		[HarmonyPostfix]
		private static void OnPlayerDeath(PlayerAvatar __instance)
		{
			if (__instance.isLocal)
			{
				VRSession.Instance?.Player.Rig.SetVisible(visible: false);
			}
		}

		[HarmonyPatch(typeof(PlayerAvatar), "ReviveRPC")]
		[HarmonyPostfix]
		private static void OnPlayerRevive(PlayerAvatar __instance)
		{
			//IL_002e: 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)
			if (__instance.isLocal)
			{
				VRSession instance = VRSession.Instance;
				if (instance != null)
				{
					instance.Player.Rig.SetVisible(visible: true);
					Transform transform = ((Component)CameraAimOffset.Instance).transform;
					transform.localRotation = Quaternion.identity;
					transform.localPosition = Vector3.zero;
				}
			}
		}

		[HarmonyPatch(typeof(PlayerAvatar), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PlayerDeathLookAtEnemyPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldsfld, (object)AccessTools.Field(typeof(CameraAim), "Instance"), (string)null)
			}).SetOperandAndAdvance((object)AccessTools.Field(typeof(VRCameraAim), "instance")).Advance(9)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Ldc_I4_1, (object)null)
				})
				.SetOperandAndAdvance((object)AccessTools.Method(typeof(VRCameraAim), "SetAimTarget", (Type[])null, (Type[])null))
				.InstructionEnumeration();
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class PlayerAvatarVisualsPatches
	{
		[HarmonyPatch(typeof(PlayerMaterial), "ColorSet")]
		[HarmonyPostfix]
		private static void OnPlayerMaterialColorChanged(PlayerMaterial __instance, int _albedoColor, int _emissionColor, int _colorIndex)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Invalid comparison between Unknown and I4
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Invalid comparison between Unknown and I4
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Invalid comparison between Unknown and I4
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			VRSession instance = VRSession.Instance;
			if (instance != null && PlayerAvatar.instance.playerCosmetics.playerMaterials.Contains(__instance) && ((int)__instance.tintType == 0 || (int)__instance.tintType == 2))
			{
				if ((int)__instance.cosmeticType == 10)
				{
					instance.Player.Rig.SetLeftArmColor(_albedoColor, MetaManager.instance.colors[_colorIndex].color);
				}
				if ((int)__instance.cosmeticType == 9)
				{
					instance.Player.Rig.SetRightArmColor(_albedoColor, MetaManager.instance.colors[_colorIndex].color);
				}
			}
		}

		[HarmonyPatch(typeof(PlayerAvatarVisuals), "ApplyLocalVisibilityBody")]
		[HarmonyPostfix]
		private static void KeepVisibleLocalPatch(PlayerAvatarVisuals __instance)
		{
			if (!__instance.isMenuAvatar)
			{
				CollectionExtensions.Do<Renderer>(from mat in ((Component)__instance.playerAvatarRightArm.grabberClawParent).GetComponentsInChildren<PlayerMaterial>(true)
					where Object.op_Implicit((Object)(object)mat)
					select ((Component)mat).GetComponent<Renderer>(), (Action<Renderer>)delegate(Renderer renderer)
				{
					renderer.shadowCastingMode = (ShadowCastingMode)1;
					((Component)renderer).gameObject.layer = 6;
				});
				((Component)__instance.playerAvatarRightArm.grabberOrb).gameObject.SetActive(true);
			}
		}

		[HarmonyPatch(typeof(PlayerCosmetics), "PlayerMaterialSetup")]
		[HarmonyPostfix]
		private static void InsertGrabberPatch(PlayerCosmetics __instance)
		{
			if (!Object.op_Implicit((Object)(object)__instance.playerAvatarVisuals) || !Object.op_Implicit((Object)(object)__instance.playerAvatarVisuals.playerAvatar) || !__instance.playerAvatarVisuals.playerAvatar.isLocal || __instance.playerAvatarVisuals.isMenuAvatar)
			{
				return;
			}
			VRSession instance = VRSession.Instance;
			if (instance != null)
			{
				PlayerMaterial[] componentsInChildren = ((Component)instance.Player.Rig).GetComponentsInChildren<PlayerMaterial>(true);
				foreach (PlayerMaterial val in componentsInChildren)
				{
					val.Setup();
					__instance.playerMaterials.Add(val);
				}
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class PlayerControllerPatches
	{
		[HarmonyPatch(typeof(PlayerController), "FixedUpdate")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ApplyCorrectWalkingForce(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(PlayerController), "cameraGameObject"), (string)null)
			}).Advance(2).SetOperandAndAdvance((object)AccessTools.PropertyGetter(typeof(Transform), "rotation"))
				.InstructionEnumeration();
		}

		[HarmonyPatch(typeof(PlayerController), "FixedUpdate")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ConditionalApplyNormalizedMove(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.PropertyGetter(typeof(Vector3), "normalized"), (string)null)
			}).Set(OpCodes.Call, (object)new Func<Vector3, Vector3>(ConditionalNormalize).Method).Advance(-2)
				.RemoveInstructions(2)
				.InstructionEnumeration();
			static Vector3 ConditionalNormalize(Vector3 input)
			{
				//IL_0015: 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 (!Plugin.Config.NormalizeMovement.Value)
				{
					return input;
				}
				return ((Vector3)(ref input)).normalized;
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class PlayerDeathHeadPatches
	{
		[HarmonyPatch(typeof(PlayerDeathHead), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> LookAtHeadPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(SemiFunc), "OnScreen", (Type[])null, (Type[])null), (string)null)
			}).SetOperandAndAdvance((object)AccessTools.Method(typeof(VREyeTracking), "LookingAt", (Type[])null, (Type[])null)).InstructionEnumeration();
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.Universal, null)]
	internal static class PlayerEyesPatches
	{
		[HarmonyPatch(typeof(PlayerEyes), "LookAtTransform")]
		[HarmonyPostfix]
		private static void LookAtTransformEyeTracking(PlayerEyes __instance)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)__instance.playerAvatar) && !__instance.playerAvatar.isLocal && NetworkSystem.instance.GetNetworkPlayer(__instance.playerAvatar, out NetworkPlayer networkPlayer) && networkPlayer.EyeTracking)
			{
				__instance.lookAtActive = true;
				((Component)__instance.lookAt).transform.position = networkPlayer.EyeGazePoint;
			}
		}

		[HarmonyPatch(typeof(PlayerAvatarVisuals), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> KeepHeadRotationPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_002b: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)40f, (string)null)
			}).SetAndAdvance(OpCodes.Ldarg_0, (object)null).Insert((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Call, (object)new Func<PlayerAvatarVisuals, float>(GetMaxAngle).Method)
			})
				.InstructionEnumeration();
			static float GetMaxAngle(PlayerAvatarVisuals visuals)
			{
				if (visuals.isMenuAvatar)
				{
					return 40f;
				}
				if (!NetworkSystem.instance.GetNetworkPlayer(visuals.playerAvatar, out NetworkPlayer networkPlayer) || !networkPlayer.EyeTracking)
				{
					return 40f;
				}
				return 0f;
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class PlayerHealthPatches
	{
		[HarmonyPatch(typeof(PlayerHealth), "Update")]
		[HarmonyPostfix]
		private static void OnPlayerHealthUpdate(PlayerHealth __instance)
		{
			if (!__instance.playerAvatar.isLocal)
			{
				return;
			}
			VRSession instance = VRSession.Instance;
			if (instance != null)
			{
				if (!__instance.materialEffect)
				{
					instance.Player.Rig.SetHurtAmount(0f);
				}
				else
				{
					instance.Player.Rig.SetHurtAmount(__instance.materialEffectCurve.Evaluate(__instance.materialEffectLerp));
				}
			}
		}

		[HarmonyPatch(typeof(PlayerHealth), "Hurt")]
		[HarmonyPostfix]
		private static void OnPlayerHurt(PlayerHealth __instance, int damage)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.invincibleTimer > 0f || damage <= 0 || (GameManager.Multiplayer() && !__instance.photonView.IsMine))
			{
				return;
			}
			if (__instance.playerAvatar.deadSet || __instance.godMode || __instance.health <= 0)
			{
				OnSetMaterialGreen(__instance);
				return;
			}
			VRSession instance = VRSession.Instance;
			if (instance != null)
			{
				__instance.materialEffect = true;
				__instance.materialEffectLerp = 0f;
				instance.Player.Rig.SetHurtColor(Color.red);
				AssetCollection.HurtHapticCurve.Pulse(HapticManager.Hand.Both, 0.8f, 2f, 10);
			}
		}

		[HarmonyPatch(typeof(PlayerHealth), "MaterialEffectOverrideRPC")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> MaterialEffectOverridePatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).End().Advance(-1).Insert((CodeInstruction[])(object)new CodeInstruction[3]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldloc_0, (object)null),
				new CodeInstruction(OpCodes.Call, (object)new Action<PlayerHealth, Color>(OnMaterialEffectOverride).Method)
			})
				.InstructionEnumeration();
			static void OnMaterialEffectOverride(PlayerHealth health, Color newColor)
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				if (health.playerAvatar.isLocal)
				{
					VRSession.Instance?.Player.Rig.SetHurtColor(newColor);
				}
			}
		}

		[HarmonyPatch(typeof(PlayerHealth), "SetMaterialGreen")]
		[HarmonyPostfix]
		private static void OnSetMaterialGreen(PlayerHealth __instance)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.playerAvatar.isLocal)
			{
				VRSession.Instance?.Player.Rig.SetHurtColor(new Color(0f, 1f, 0.25f));
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class PlayerNetworkPatches
	{
		[HarmonyPatch(typeof(NetworkManager), "PlayerSpawnedRPC")]
		[HarmonyPostfix]
		private static void OnPlayerJoined()
		{
			NetworkSystem.instance.AnnounceVRPlayer();
		}
	}
}
namespace RepoXR.Patches.Item
{
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class ItemRubberDuckPatches
	{
		[HarmonyPatch(typeof(ItemRubberDuck), "Squeak")]
		[HarmonyPrefix]
		private static bool NoSqueakIfEquipped(ItemRubberDuck __instance)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			return (int)__instance.itemEquippable.currentState != 2;
		}

		[HarmonyPatch(typeof(ItemRubberDuck), "Quack")]
		[HarmonyPrefix]
		private static bool NoQuackIfEquipped(ItemRubberDuck __instance)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			return (int)__instance.itemEquippable.currentState != 2;
		}

		[HarmonyPatch(typeof(ItemRubberDuck), "QuackRPC")]
		[HarmonyPrefix]
		private static bool NoQuackRPCIfEquipped(ItemRubberDuck __instance)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			return (int)__instance.itemEquippable.currentState != 2;
		}

		[HarmonyPatch(typeof(ItemRubberDuck), "LilQuackJump")]
		[HarmonyPrefix]
		private static bool NoJumpIfEquipped(ItemRubberDuck __instance)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			return (int)__instance.itemEquippable.currentState != 2;
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.Universal, null)]
	internal static class ItemVehiclePatches
	{
		[HarmonyPatch(typeof(ItemVehicle), "ApplyVehicleDrift")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DriftDeadzonePatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_002b: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)0.1f, (string)null)
			}).SetOpcodeAndAdvance(OpCodes.Ldarg_0).Insert((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Call, (object)new Func<ItemVehicle, float>(GetDriftDeadzone).Method)
			})
				.InstructionEnumeration();
			static float GetDriftDeadzone(ItemVehicle vehicle)
			{
				if (!vehicle.currentDriver.IsVRPlayer())
				{
					return 0.1f;
				}
				return 0.5f;
			}
		}

		[HarmonyPatch(typeof(ItemVehicle), "ApplyVehicleMovement")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ApplyVehicleMovementPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(PlayerLocalCamera), "GetOverrideTransform", (Type[])null, (Type[])null), (string)null)
			}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher m)
			{
				m.Set(OpCodes.Call, (object)new Func<PlayerLocalCamera, Transform>(GetVehicleTargetForward).Method);
			}, (Action<string>)null).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(ItemVehicle), "ApplyVehicleSteering")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ApplyVehicleSteeringPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(PlayerLocalCamera), "GetOverrideTransform", (Type[])null, (Type[])null), (string)null)
			}).Set(OpCodes.Call, (object)new Func<PlayerLocalCamera, Transform>(GetVehicleTargetForward).Method).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(ItemVehicle), "ApplyVehicleDrift")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ApplyVehicleDriftPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(PlayerLocalCamera), "GetOverrideTransform", (Type[])null, (Type[])null), (string)null)
			}).Set(OpCodes.Call, (object)new Func<PlayerLocalCamera, Transform>(GetVehicleTargetForward).Method).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(ItemVehicle), "UpdateSteering")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UpdateSteeringPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(PlayerLocalCamera), "GetOverrideTransform", (Type[])null, (Type[])null), (string)null)
			}).Set(OpCodes.Call, (object)new Func<PlayerLocalCamera, Transform>(GetVehicleTargetForward).Method).InstructionEnumeration();
		}

		[HarmonyPatch(typeof(ItemVehicle), "LocalMeshUpdate")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> LateUpdatePatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(PlayerLocalCamera), "GetOverrideTransform", (Type[])null, (Type[])null), (string)null)
			}).Advance(1).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(PlayerLocalCamera), "GetOverrideTransform", (Type[])null, (Type[])null), (string)null)
			})
				.Set(OpCodes.Call, (object)new Func<PlayerLocalCamera, Transform>(GetVehicleTargetForward).Method)
				.InstructionEnumeration();
		}

		private static Transform GetVehicleTargetForward(PlayerLocalCamera camera)
		{
			PlayerAvatar playerAvatar = camera.playerAvatar;
			if (playerAvatar.isLocal && VRSession.InVR)
			{
				if (!VRSession.Instance.Player.NetworkPlayer.VehicleHeadForward)
				{
					return playerAvatar.localCamera.GetHandOverrideTransform();
				}
				return playerAvatar.localCamera.GetOverrideTransform();
			}
			if (NetworkSystem.instance.GetNetworkPlayer(playerAvatar, out NetworkPlayer networkPlayer))
			{
				if (!networkPlayer.VehicleHeadForward)
				{
					return playerAvatar.localCamera.GetHandOverrideTransform();
				}
				return playerAvatar.localCamera.GetOverrideTransform();
			}
			return playerAvatar.localCamera.GetOverrideTransform();
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class ItemBoomboxPatches
	{
		[HarmonyPatch(typeof(ValuableBoombox), "Update")]
		[HarmonyPostfix]
		private static void BoomboxAimPatch(ValuableBoombox __instance)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00d9: Unknown result type (might be due to invalid IL or missing references)
			if (((Trap)__instance).physGrabObject.grabbed && Object.op_Implicit((Object)(object)PhysGrabber.instance) && !((Object)(object)PhysGrabber.instance.grabbedObject != (Object)(object)((Trap)__instance).physGrabObject.rb))
			{
				int num = (Plugin.Config.ReducedAimImpact.Value ? 5 : 15);
				float num2 = (Plugin.Config.ReducedAimImpact.Value ? 0.15f : 0.5f);
				Vector3 position = ((Component)PhysGrabber.instance.playerAvatar.localCamera).transform.position;
				Vector3 val = ((Component)PhysGrabber.instance.playerAvatar.localCamera).transform.forward * 2f;
				Vector3 val2 = Vector3.up * Mathf.Sin(Time.time * (float)num) * num2;
				Vector3 position2 = position + val + val2;
				VRCameraAim.instance.SetAimTargetSoft(position2, 0.01f, 10f, 10f, ((Component)__instance).gameObject, 100);
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class ItemGumballPatches
	{
		[HarmonyPatch(typeof(GumballValuable), "CameraAimAndZoom")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> LookAtPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldsfld, (object)AccessTools.Field(typeof(CameraAim), "Instance"), (string)null)
			}).SetOperandAndAdvance((object)AccessTools.Field(typeof(VRCameraAim), "instance")).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(CameraAim), "AimTargetSoftSet", (Type[])null, (Type[])null), (string)null)
			})
				.SetAndAdvance(OpCodes.Call, (object)Plugin.GetConfigGetter())
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[3]
				{
					new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(Config), "ReducedAimImpact")),
					new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(ConfigEntry<bool>), "Value")),
					new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(VRCameraAim), "SetAimTargetSoft", (Type[])null, (Type[])null))
				})
				.InstructionEnumeration();
		}
	}
}
namespace RepoXR.Patches.Enemy
{
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class EnemyBeamerPatches
	{
		[HarmonyPatch(typeof(EnemyBeamer), "LaserLogic")]
		[HarmonyPostfix]
		private static void BeamerLaserHaptic(EnemyBeamer __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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)
			if ((int)__instance.currentState == 5)
			{
				Vector3 position = ((Component)PlayerAvatar.instance).transform.position;
				float num = Vector3.Distance(__instance.laserStartTransform.position, position);
				float num2 = Vector3.Distance(__instance.hitPosition, position);
				float num3 = Mathf.Min(num, num2);
				float num4 = Mathf.InverseLerp(15f, 3f, num3);
				HapticManager.Impulse(HapticManager.Hand.Both, HapticManager.Type.Continuous, 0.6f * num4, 0.1f, 2);
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class EnemyCeilingEyePatches
	{
		[HarmonyPatch(typeof(EnemyCeilingEye), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> SetCameraSoftRotationPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Expected O, but got Unknown
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Expected O, but got Unknown
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Expected O, but got Unknown
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Expected O, but got Unknown
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Expected O, but got Unknown
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Expected O, but got Unknown
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(CameraAim), "AimTargetSoftSet", (Type[])null, (Type[])null), (string)null)
			}).Advance(-11).SetOperandAndAdvance((object)AccessTools.Field(typeof(VRCameraAim), "instance"))
				.Advance(10)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)Plugin.GetConfigGetter())
				})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(Config), "ReducedAimImpact"))
				})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(ConfigEntry<bool>), "Value"))
				})
				.SetOperandAndAdvance((object)AccessTools.Method(typeof(VRCameraAim), "SetAimTargetSoft", (Type[])null, (Type[])null))
				.Insert((CodeInstruction[])(object)new CodeInstruction[9]
				{
					new CodeInstruction(OpCodes.Call, (object)AccessTools.PropertyGetter(typeof(VRSession), "Instance")),
					new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(VRSession), "FocusSphere")),
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(EnemyCeilingEye), "enemy")),
					new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(Enemy), "CenterTransform")),
					new CodeInstruction(OpCodes.Ldc_R4, (object)0.5f),
					new CodeInstruction(OpCodes.Ldc_R4, (object)2f),
					new CodeInstruction(OpCodes.Ldc_R4, (object)1f),
					new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(FocusSphere), "SetLookAtTarget", (Type[])null, (Type[])null))
				})
				.InstructionEnumeration();
		}

		[HarmonyPatch(typeof(EnemyCeilingEye), "Update")]
		[HarmonyPostfix]
		private static void EyeAttachHapticFeedback(EnemyCeilingEye __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)__instance.currentState == 3 && Object.op_Implicit((Object)(object)__instance.targetPlayer) && __instance.targetPlayer.isLocal)
			{
				HapticManager.Impulse(HapticManager.Hand.Both, HapticManager.Type.Continuous, 0.2f * AssetCollection.EyeAttachHapticCurve.EvaluateTimed(0.25f), 0.1f, 11);
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class EnemyHeartHuggerPatches
	{
		[HarmonyPatch(typeof(EnemyHeartHugger), "JumpScareAtChompStartForceLookAtHead")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> LookAtPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldsfld, (object)AccessTools.Field(typeof(CameraAim), "Instance"), (string)null)
			}).SetOperandAndAdvance((object)AccessTools.Field(typeof(VRCameraAim), "instance")).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(CameraAim), "AimTargetSoftSet", (Type[])null, (Type[])null), (string)null)
			})
				.SetAndAdvance(OpCodes.Call, (object)Plugin.GetConfigGetter())
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[3]
				{
					new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(Config), "ReducedAimImpact")),
					new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(ConfigEntry<bool>), "Value")),
					new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(VRCameraAim), "SetAimTargetSoft", (Type[])null, (Type[])null))
				})
				.InstructionEnumeration();
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class EnemyOnScreenPatches
	{
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> LogicPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(SemiFunc), "OnScreen", (Type[])null, (Type[])null), (string)null)
			}).SetOperandAndAdvance((object)AccessTools.Method(typeof(VREyeTracking), "LookingAt", (Type[])null, (Type[])null)).InstructionEnumeration();
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class EnemyOoglyPatches
	{
		[HarmonyPatch(typeof(EnemyOogly), "UpdateEvilEyesTimer")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> LookAtPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldsfld, (object)AccessTools.Field(typeof(CameraAim), "Instance"), (string)null)
			}).SetOperandAndAdvance((object)AccessTools.Field(typeof(VRCameraAim), "instance")).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(CameraAim), "AimTargetSet", (Type[])null, (Type[])null), (string)null)
			})
				.SetAndAdvance(OpCodes.Call, (object)Plugin.GetConfigGetter())
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[3]
				{
					new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(Config), "ReducedAimImpact")),
					new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(ConfigEntry<bool>), "Value")),
					new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(VRCameraAim), "SetAimTarget", (Type[])null, (Type[])null))
				})
				.InstructionEnumeration();
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class EnemySlowMouthPatches
	{
		[HarmonyPatch(typeof(EnemySlowMouthAttached), "StatePuke")]
		[HarmonyPostfix]
		private static void PukeHaptics()
		{
			HapticManager.Impulse(HapticManager.Hand.Both, HapticManager.Type.Continuous, 0.25f, 0.1f, 3);
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class EnemySpinnyPatches
	{
		[HarmonyPatch(typeof(EnemySpinny), "OverrideTargetPlayerCameraAim")]
		[HarmonyPrefix]
		private static bool OverrideVRCameraAim(EnemySpinny __instance, float _strenght, float _strenghtNoAim)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			VRCameraAim.instance.SetAimTargetSoft(__instance.spinnyWheel.position, 0.1f, _strenght, _strenghtNoAim, ((Component)__instance).gameObject, 100, lowImpact: true);
			return false;
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class EnemyThinManPatches
	{
		[HarmonyPatch(typeof(EnemyThinManAnim), "NoticeSet")]
		[HarmonyPostfix]
		private static void OnThinManAttack(EnemyThinManAnim __instance)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.enemy.Health.healthCurrent >= 0 && __instance.controller.playerTarget.isLocal)
			{
				VRCameraZoom.instance.SetZoomTarget(2f, 0.75f, 3f, 1f, __instance.controller.head.transform, 90);
				VRCameraAim.instance.SetAimTarget(__instance.controller.head.transform.position, 0.75f, 2f, ((Component)__instance.controller).gameObject, 90, lowImpact: true);
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class EnemyUpscreamPatches
	{
		[HarmonyPatch(typeof(EnemyUpscream), "Update")]
		[HarmonyPostfix]
		private static void OnUpscreamAttack(EnemyUpscream __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if ((int)__instance.currentState == 6 && Object.op_Implicit((Object)(object)__instance.targetPlayer) && __instance.targetPlayer.isLocal)
			{
				VRCameraAim.instance.SetAimTarget(__instance.visionTransform.position, 0.1f, 5f, ((Component)__instance).gameObject, 90, Plugin.Config.ReducedAimImpact.Value);
				VRCameraZoom.instance.SetZoomTarget(-0.15f, 0.1f, 5f, 5f, __instance.visionTransform, 50);
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class ShopKeeperPatches
	{
		[HarmonyPatch(typeof(ShopKeeper), "PlayerEyesOverrideLogic")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PlayerEyesVROverride(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldsfld, (object)AccessTools.Field(typeof(CameraAim), "Instance"), (string)null)
			}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher matcher)
			{
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Expected O, but got Unknown
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Expected O, but got Unknown
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Expected O, but got Unknown
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Expected O, but got Unknown
				matcher.SetOperandAndAdvance((object)AccessTools.Field(typeof(VRCameraAim), "instance")).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(CameraAim), "AimTargetSet", (Type[])null, (Type[])null), (string)null)
				}).SetAndAdvance(OpCodes.Call, (object)Plugin.GetConfigGetter())
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[3]
					{
						new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(Config), "ReducedAimImpact")),
						new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(ConfigEntry<bool>), "Value")),
						new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(VRCameraAim), "SetAimTarget", (Type[])null, (Type[])null))
					})
					.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
					{
						new CodeMatch((OpCode?)OpCodes.Ldsfld, (object)AccessTools.Field(typeof(CameraAim), "Instance"), (string)null)
					});
			}, (Action<string>)null).InstructionEnumeration();
		}
	}
}
namespace RepoXR.Networking
{
	public static class NetworkingExtensions
	{
		public static bool IsVRPlayer(this PlayerAvatar player)
		{
			if (!player.isLocal || !VRSession.InVR)
			{
				if (!player.isLocal)
				{
					return NetworkSystem.instance.IsVRPlayer(player);
				}
				return false;
			}
			return true;
		}
	}
	[DefaultExecutionOrder(100)]
	public class NetworkPlayer : MonoBehaviour
	{
		internal PlayerAvatar playerAvatar;

		private PlayerAvatarVisuals playerAvatarVisuals;

		private PlayerAvatarLeftArm playerLeftArm;

		private PlayerAvatarRightArm playerRightArm;

		private FlashlightController flashlight;

		private MapToolController mapTool;

		private Transform rigContainer;

		private Transform leftHandTarget;

		private Transform rightHandTarget;

		private Transform leftHandAnchor;

		private Transform rightHandAnchor;

		private Transform headlampTransform;

		private Vector3 leftHandPosition;

		private Vector3 rightHandPosition;

		private Quaternion leftHandRotation;

		private Quaternion rightHandRotation;

		private bool networkReady;

		private bool isLeftHanded;

		private bool isMapLeftHanded;

		private bool isHeadlampEnabled;

		public Transform PrimaryHand
		{
			get
			{
				if (!isLeftHanded)
				{
					return rightHandTarget;
				}
				return leftHandTarget;
			}
		}

		public bool EyeTracking { get; private set; }

		public Vector3 EyeGazePoint { get; private set; }

		public bool VehicleHeadForward { get; private set; }

		private void Start()
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: 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_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_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: 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_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			NetworkSystem.instance.RegisterRPCBehaviour(this, playerAvatar.photonView);
			if (playerAvatar.isLocal)
			{
				Plugin.Config.VehicleHeadForward.SettingChanged += OnVehicleHeadForwardChanged;
				((Behaviour)this).enabled = false;
				return;
			}
			playerAvatarVisuals = playerAvatar.playerAvatarVisuals;
			playerLeftArm = ((Component)playerAvatarVisuals).GetComponent<PlayerAvatarLeftArm>();
			playerRightArm = ((Component)playerAvatarVisuals).GetComponent<PlayerAvatarRightArm>();
			GameObject val = new GameObject("VR Player Rig Container");
			val.transform.parent = ((Component)this).transform;
			val.transform.localPosition = Vector3.zero;
			val.transform.localRotation = Quaternion.identity;
			rigContainer = val.transform;
			GameObject val2 = new GameObject("Left Hand");
			val2.transform.parent = rigContainer;
			leftHandTarget = val2.transform;
			GameObject val3 = new GameObject("Right Hand");
			val3.transform.parent = rigContainer;
			rightHandTarget = val3.transform;
			GameObject val4 = new GameObject("Left Hand Anchor");
			val4.transform.parent = playerLeftArm.leftArmTransform;
			val4.transform.localPosition = Vector3.forward * 0.513f;
			leftHandAnchor = val4.transform;
			GameObject val5 = new GameObject("Right Hand Anchor");
			val5.transform.parent = playerRightArm.rightArmTransform.Find("ANIM ARM R SCALE");
			val5.transform.localPosition = Vector3.forward * 0.513f;
			rightHandAnchor = val5.transform;
			GameObject val6 = new GameObject("Headlamp Anchor");
			val6.transform.parent = playerAvatarVisuals.attachPointTopHeadMiddle;
			val6.transform.localPosition = new Vector3(isLeftHanded ? 0.21f : (-0.21f), 0.1f, 0f);
			headlampTransform = val6.transform;
			Transform parent = ((Component)playerAvatar).transform.parent;
			flashlight = ((Component)parent).GetComponentInChildren<FlashlightController>(true);
			((Component)flashlight).transform.parent = ((Component)this).transform;
			((Component)flashlight).transform.localScale = Vector3.one * flashlight.hiddenScale;
			((Component)flashlight).transform.localPosition = Vector3.zero;
			((Component)flashlight).transform.localRotation = Quaternion.identity;
			((Component)flashlight.meshShadows).gameObject.SetActive(false);
			((Renderer)flashlight.mesh).shadowCastingMode = (ShadowCastingMode)1;
			mapTool = ((Component)parent).GetComponentInChildren<MapToolController>(true);
			((Component)mapTool).transform.parent.parent = ((Component)this).transform;
			((Component)mapTool).transform.parent.localPosition = Vector3.zero;
			((Component)mapTool).transform.parent.localRotation = Quaternion.identity;
			playerRightArm.grabberClawParent.SetParent(isLeftHanded ? leftHandAnchor : rightHandAnchor);
			playerRightArm.grabberClawParent.localPosition = Vector3.zero;
			playerRightArm.physGrabBeam.PhysGrabPointOrigin.SetParent(isLeftHanded ? leftHandAnchor : rightHandAnchor);
			playerRightArm.physGrabBeam.PhysGrabPointOrigin.localPosition = Vector3.zero;
			networkReady = true;
		}

		private void Update()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: 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_00a7: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)playerAvatarVisuals) || !Object.op_Implicit((Object)(object)mapTool))
			{
				((Behaviour)this).enabled = false;
				return;
			}
			((Component)this).transform.position = ((Component)playerAvatarVisuals).transform.position;
			leftHandTarget.position = Vector3.Lerp(leftHandTarget.position, leftHandPosition, 15f * Time.deltaTime);
			leftHandTarget.rotation = Quaternion.Slerp(leftHandTarget.rotation, leftHandRotation, 15f * Time.deltaTime);
			rightHandTarget.position = Vector3.Lerp(rightHandTarget.position, rightHandPosition, 15f * Time.deltaTime);
			rightHandTarget.rotation = Quaternion.Slerp(rightHandTarget.rotation, rightHandRotation, 15f * Time.deltaTime);
			UpdateArmFixed(playerRightArm.rightArmTransform, rightHandTarget, isRight: true);
			UpdateArmFixed(playerLeftArm.leftArmTransform, leftHandTarget, isRight: false);
			leftHandAnchor.rotation = leftHandTarget.rotation;
			rightHandAnchor.rotation = rightHandTarget.rotation;
		}

		private void UpdateArmFixed(Transform armRoot, Transform target, bool isRight)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: 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_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			if (playerAvatar.isTumbling)
			{
				armRoot.localPosition = Vector3.Lerp(armRoot.localPosition, Vector3.zero, 15f * Time.deltaTime);
				return;
			}
			Transform bodyTopUpTransform = playerAvatarVisuals.bodyTopUpTransform;
			Vector3 position = bodyTopUpTransform.position;
			Vector3 val = target.position - position;
			val.y = 0f;
			if (!(((Vector3)(ref val)).sqrMagnitude < 0.0001f))
			{
				((Vector3)(ref val)).Normalize();
				Vector3 val2 = bodyTopUpTransform.InverseTransformDirection(val);
				float num = Mathf.Atan2(val2.x, val2.z) * 57.29578f;
				float num2 = (isRight ? 90f : (-90f));
				float num3 = Mathf.DeltaAngle(num2, num);
				float num4 = (isRight ? (0f - num3) : num3);
				float num5 = ((num4 > 60f) ? Mathf.Clamp01((num4 - 60f) / 30f) : 0f);
				float num6 = Mathf.Clamp(Mathf.LerpAngle(num2, num, num5), -140f, 140f);
				Vector3 val3 = Quaternion.Euler(0f, num6, 0f) * Vector3.forward;
				Vector3 val4 = bodyTopUpTransform.TransformDirection(val3);
				Vector3 val5 = position + val4 * 0.275f;
				armRoot.position = Vector3.Lerp(armRoot.position, val5 + 0.255f * Vector3.up, Time.deltaTime * 15f);
				armRoot.LookAt(target);
			}
		}

		private void LateUpdate()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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)
			Transform val = (isLeftHanded ? rightHandAnchor : leftHandAnchor);
			if (!isHeadlampEnabled)
			{
				((Component)flashlight).transform.position = val.position;
				((Component)flashlight).transform.rotation = val.rotation;
			}
			val = (isMapLeftHanded ? leftHandAnchor : rightHandAnchor);
			((Component)mapTool).transform.parent.position = val.position;
			((Component)mapTool).transform.parent.rotation = val.rotation;
		}

		private void OnDestroy()
		{
			if (playerAvatar.isLocal)
			{
				Plugin.Config.VehicleHeadForward.SettingChanged -= OnVehicleHeadForwardChanged;
			}
		}

		private void OnVehicleHeadForwardChanged(object sender, EventArgs e)
		{
			UpdateVehicleHeadForwardRPC(Plugin.Config.VehicleHeadForward.Value);
		}

		[XRRpc(false)]
		public void UpdateRigRPC(Vector3 leftPosition, Quaternion leftRotation, Vector3 rightPosition, Quaternion rightRotation)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			leftHandPosition = leftPosition;
			leftHandRotation = leftRotation;
			rightHandPosition = rightPosition;
			rightHandRotation = rightRotation;
		}

		[XRRpc(false)]
		public void UpdateMapRPC(bool leftHanded, bool hideFlashlight)
		{
			isMapLeftHanded = leftHanded;
			if (networkReady)
			{
				flashlight.hideFlashlight = hideFlashlight;
			}
		}

		[XRRpc(false)]
		public void UpdateHeadlampRPC(bool headlampEnabled)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			isHeadlampEnabled = headlampEnabled;
			if (networkReady)
			{
				((Component)flashlight).transform.SetParent((Transform)(headlampEnabled ? ((object)headlampTransform) : ((object)((Component)this).transform)));
				((Component)flashlight).transform.localPosition = Vector3.zero;
				((Component)flashlight).transform.localRotation = Quaternion.identity;
			}
		}

		[XRRpc(false)]
		public void UpdateDominantHandRPC(bool leftHanded)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			isLeftHanded = leftHanded;
			if (networkReady)
			{
				((Component)flashlight).transform.parent = (Transform)(isHeadlampEnabled ? ((object)headlampTransform) : ((object)((Component)this).transform));
				((Component)flashlight).transform.localScale = Vector3.one * flashlight.hiddenScale;
				((Component)flashlight).transform.localPosition = Vector3.zero;
				((Component)flashlight).transform.localRotation = Quaternion.identity;
				((Component)headlampTransform).transform.localPosition = new Vector3(isLeftHanded ? 0.21f : (-0.21f), 0.1f, 0f);
				playerRightArm.grabberClawParent.SetParent(isLeftHanded ? leftHandAnchor : rightHandAnchor);
				playerRightArm.grabberClawParent.localPosition = Vector3.zero;
				playerRightArm.physGrabBeam.PhysGrabPointOrigin.SetParent(isLeftHanded ? leftHandAnchor : rightHandAnchor);
				playerRightArm.physGrabBeam.PhysGrabPointOrigin.localPosition = Vector3.zero;
			}
		}

		[XRRpc(false)]
		public void UpdateEyeTrackingRPC(Vector3 gazePoint)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			EyeTracking = true;
			EyeGazePoint = gazePoint;
		}

		[XRRpc(false)]
		public void DisableEyeTrackingRPC()
		{
			EyeTracking = false;
		}

		[XRRpc(true)]
		public void UpdateVehicleHeadForwardRPC(bool headForward)
		{
			VehicleHeadForward = headForward;
		}
	}
	public class NetworkSystem : MonoBehaviour
	{
		private const long REPOXR_MAGIC = 90457653598290L;

		private const int PROTOCOL_VERSION = 2;

		public static NetworkSystem instance;

		private readonly Dictionary<int, NetworkPlayer> networkPlayers = new Dictionary<int, NetworkPlayer>();

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

		private readonly Dictionary<ulong, Dictionary<ulong, MethodInfo>> rpcHashcodes = new Dictionary<ulong, Dictionary<ulong, MethodInfo>>();

		private readonly Dictionary<int, Dictionary<ulong, MonoBehaviour>> rpcInstances = new Dictionary<int, Dictionary<ulong, MonoBehaviour>>();

		private readonly Dictionary<MonoBehaviour, PhotonView> rpcViews = new Dictionary<MonoBehaviour, PhotonView>();

		private readonly List<RPCFrame> rpcBuffer = new List<RPCFrame>();

		private void Awake()
		{
			if (Object.op_Implicit((Object)(object)instance))
			{
				instance.networkPlayers.Clear();
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
			else
			{
				instance = this;
				Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
				PrecomputeRpcHashes();
			}
		}

		private void PrecomputeRpcHashes()
		{
			rpcHashcodes.Clear();
			Type[] typesFromAssembly = AccessTools.GetTypesFromAssembly(Assembly.GetExecutingAssembly());
			foreach (Type type in typesFromAssembly)
			{
				if (type == null)
				{
					continue;
				}
				ulong networkHash = type.GetNetworkHash();
				foreach (MethodInfo item in from m in type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
					where m.GetCustomAttribute<XRRpcAttribute>() != null
					select m)
				{
					if (item.GetParameters().Length > 6)
					{
						Logger.LogWarning("RPC " + type.FullName + "::" + item.Name + " contains too many parameters and will be ignored");
					}
					else
					{
						ulong networkHash2 = item.GetNetworkHash();
						if (!rpcHashcodes.ContainsKey(networkHash))
						{
							rpcHashcodes.Add(networkHash, new Dictionary<ulong, MethodInfo>());
						}
						rpcHashcodes[networkHash][networkHash2] = item;
					}
				}
			}
		}

		public bool GetNetworkPlayer(PlayerAvatar player, out NetworkPlayer networkPlayer)
		{
			return networkPlayers.TryGetValue(player.photonView.ControllerActorNr, out networkPlayer);
		}

		public bool IsVRPlayer(PlayerAvatar player)
		{
			return cachedPhotonIds.Contains(player.photonView.ControllerActorNr);
		}

		public bool IsVRView(PhotonView view)
		{
			return cachedPhotonIds.Contains(view.ControllerActorNr);
		}

		public void AnnounceVRPlayer()
		{
			EnqueueRPC(RPCFrame.CreateAnnouncement());
		}

		private void EnqueueRPC(RPCFrame rpc, bool deduplicate = true)
		{
			if (deduplicate)
			{
				rpcBuffer.ReplaceOrInsert(rpc, (RPCFrame f) => f.Matches(rpc));
			}
			else
			{
				rpcBuffer.Add(rpc);
			}
		}

		public void RegisterRPCBehaviour<T>(T behaviour, PhotonView view) where T : MonoBehaviour
		{
			ulong networkHash = typeof(T).GetNetworkHash();
			if (!rpcHashcodes.ContainsKey(networkHash))
			{
				throw new InvalidOperationException($"Type {typeof(T)} has not been registered during RPC discovery");
			}
			if (!rpcInstances.ContainsKey(view.controllerActorNr))
			{
				rpcInstances[view.controllerActorNr] = new Dictionary<ulong, MonoBehaviour>();
			}
			rpcViews[(MonoBehaviour)(object)behaviour] = view;
			rpcInstances[view.controllerActorNr][networkHash] = (MonoBehaviour)(object)behaviour;
		}

		internal bool ExecuteRPC(MonoBehaviour behaviour, MethodBase method, object[] args, bool self)
		{
			if (!SemiFunc.IsMultiplayer())
			{
				return self;
			}
			ulong networkHash = ((object)behaviour).GetType().GetNetworkHash();
			ulong networkHash2 = method.GetNetworkHash();
			if (!rpcViews.TryGetValue(behaviour, out PhotonView value))
			{
				throw new InvalidOperationException($"Attempt to execute RPC {method} while not initialized");
			}
			if (!value.IsMine)
			{
				return true;
			}
			EnqueueRPC(new RPCFrame
			{
				typeHash = networkHash,
				methodHash = networkHash2,
				arguments = args
			});
			return self;
		}

		private void HandleRPC(PlayerAvatar player, ulong typeHash, ulong methodHash, object[] args)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<ulong, MethodInfo> value;
			MethodInfo value2;
			Dictionary<ulong, MonoBehaviour> value3;
			MonoBehaviour value4;
			if (typeHash == 0L && methodHash == 0L)
			{
				if (!networkPlayers.ContainsKey(player.photonView.ControllerActorNr))
				{
					NetworkPlayer networkPlayer = new GameObject("VR Player Rig - " + player.playerName).AddComponent<NetworkPlayer>();
					networkPlayer.playerAvatar = player;
					networkPlayers.Add(player.photonView.ControllerActorNr, networkPlayer);
					cachedPhotonIds.Add(player.photonView.ControllerActorNr);
				}
			}
			else if (rpcHashcodes.TryGetValue(typeHash, out value) && value.TryGetValue(methodHash, out value2) && rpcInstances.TryGetValue(player.photonView.controllerActorNr, out value3) && value3.TryGetValue(typeHash, out value4))
			{
				value2.Invoke(value4, args);
			}
		}

		internal void ResetCache()
		{
			rpcBuffer.Clear();
			networkPlayers.Clear();
			cachedPhotonIds.Clear();
		}

		internal void OnPlayerLeave(int actorNumber)
		{
			if (networkPlayers.Remove(actorNumber, out NetworkPlayer value))
			{
				Object.Destroy((Object)(object)((Component)value).gameObject);
			}
			cachedPhotonIds.Remove(actorNumber);
			CollectionExtensions.Do<MonoBehaviour>((IEnumerable<MonoBehaviour>)rpcViews.Keys.Where((MonoBehaviour k) => (Object)(object)k == (Object)null).ToList(), (Action<MonoBehaviour>)delegate(MonoBehaviour b)
			{
				rpcViews.Remove(b);
			});
			rpcInstances.Remove(actorNumber);
		}

		internal void WriteAdditionalData(PhotonStream stream)
		{
			if (rpcBuffer.Count == 0)
			{
				return;
			}
			stream.SendNext((object)90457653598290L);
			stream.SendNext((object)2);
			stream.SendNext((object)rpcBuffer.Count);
			foreach (RPCFrame item in rpcBuffer)
			{
				stream.SendNext((object)(long)item.typeHash);
				stream.SendNext((object)(long)item.methodHash);
				stream.SendNext((object)item.arguments.Length);
				object[] arguments = item.arguments;
				foreach (object obj in arguments)
				{
					stream.SendNext(obj);
				}
			}
			rpcBuffer.Clear();
		}

		internal void ReadAdditionalData(PlayerAvatar playerAvatar, PhotonStream stream)
		{
			try
			{
				if (stream.currentItem >= stream.Count || (long)stream.PeekNext() != 90457653598290L)
				{
					return;
				}
				stream.ReceiveNext();
				if ((int)stream.ReceiveNext() != 2)
				{
					return;
				}
				int num = (int)stream.ReceiveNext();
				if (num > 32)
				{
					throw new InvalidOperationException("Too many RPCs during a single read");
				}
				for (int i = 0; i < num; i++)
				{
					ulong typeHash = (ulong)(long)stream.ReceiveNext();
					ulong methodHash = (ulong)(long)stream.ReceiveNext();
					object[] array = new object[(int)stream.ReceiveNext()];
					for (int j = 0; j < array.Length; j++)
					{
						array[j] = stream.ReceiveNext();
					}
					try
					{
						HandleRPC(playerAvatar, typeHash, methodHash, array);
					}
					catch (Exception arg)
					{
						Logger.LogWarning($"Exception during handling of RPC frame: {arg}");
					}
				}
			}
			catch
			{
			}
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.Universal, null)]
	internal static class NetworkingPatches
	{
		[HarmonyPatch(typeof(PlayerLocalCamera), "OnPhotonSerializeView")]
		[HarmonyPostfix]
		private static void OnAfterSerializeView(PlayerLocalCamera __instance, PhotonStream stream, PhotonMessageInfo info)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.MasterAndOwnerOnlyRPC(info, __instance.photonView))
			{
				if (stream.IsWriting)
				{
					NetworkSystem.instance.WriteAdditionalData(stream);
				}
				else
				{
					NetworkSystem.instance.ReadAdditionalData(__instance.playerAvatar ?? ((Component)((Component)__instance).transform.parent).GetComponentInChildren<PlayerAvatar>(true), stream);
				}
			}
		}

		[HarmonyPatch(typeof(NetworkManager), "OnPlayerLeftRoom")]
		[HarmonyPostfix]
		private static void OnPlayerLeave(Player otherPlayer)
		{
			NetworkSystem.instance.OnPlayerLeave(otherPlayer.ActorNumber);
		}

		[HarmonyPatch(typeof(MenuPageMain), "Start")]
		[HarmonyPostfix]
		private static void OnMainMenuEntered()
		{
			NetworkSystem.instance.ResetCache();
		}

		internal static bool ExecuteRPCPrefix(object __instance, MethodBase __originalMethod, object[] __args)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			return NetworkSystem.instance.ExecuteRPC((MonoBehaviour)__instance, __originalMethod, __args, self: false);
		}

		internal static bool ExecuteRPCPrefixSelf(object __instance, MethodBase __originalMethod, object[] __args)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			return NetworkSystem.instance.ExecuteRPC((MonoBehaviour)__instance, __originalMethod, __args, self: true);
		}
	}
	[AttributeUsage(AttributeTargets.Method)]
	public class XRRpcAttribute : Attribute
	{
		[CompilerGenerated]
		private bool <self>P;

		public bool Self => <self>P;

		public XRRpcAttribute(bool self = false)
		{
			<self>P = self;
			base..ctor();
		}
	}
}
namespace RepoXR.Networking.Frames
{
	public struct RPCFrame
	{
		public ulong typeHash;

		public ulong methodHash;

		public object[] arguments;

		public static RPCFrame CreateAnnouncement()
		{
			RPCFrame result = default(RPCFrame);
			result.typeHash = 0uL;
			result.methodHash = 0uL;
			result.arguments = Array.Empty<object>();
			return result;
		}

		public bool Matches(RPCFrame other)
		{
			if (other.typeHash == typeHash)
			{
				return other.methodHash == methodHash;
			}
			return false;
		}
	}
}
namespace RepoXR.Managers
{
	public class DataManager : MonoBehaviour
	{
		public static DataManager instance;

		public bool headlampEnabled;

		public List<ExpressionPart.Expression> activeExpressions = new List<ExpressionPart.Expression>();

		private void Awake()
		{
			if (Object.op_Implicit((Object)(object)instance))
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
		}

		public void ResetData()
		{
			headlampEnabled = false;
			activeExpressions.Clear();
		}
	}
	public class HapticManager : MonoBehaviour
	{
		public enum Type
		{
			Impulse,
			Continuous
		}

		public enum Hand
		{
			Left,
			Right,
			Both,
			Dominant,
			Secondary
		}

		private static HapticManager instance;

		private AnimationCurveData? currentCurve;

		private Hand currentHand;

		private float currentAmplitude;

		private float curveTimer;

		private float curveSpeed;

		private int currentPriority = -999;

		private float priorityTimer;

		private void Awake()
		{
			if ((Object)(object)instance != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
		}

		private void Update()
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			if (priorityTimer > 0f)
			{
				priorityTimer -= Time.deltaTime;
				if (priorityTimer <= 0f)
				{
					currentPriority = -999;
				}
			}
			if (currentCurve != null && currentCurve.curve.length != 0)
			{
				Execute(currentHand, Type.Impulse, currentAmplitude * currentCurve.Evaluate(curveTimer), 0.1f);
				Keyframe val = currentCurve.curve[currentCurve.curve.length - 1];
				float time = ((Keyframe)(ref val)).time;
				curveTimer += Time.deltaTime * curveSpeed;
				if (!(curveTimer < time))
				{
					currentPriority = -999;
					currentCurve = null;
				}
			}
		}

		private static void Execute(Hand hand, Type type, float amplitude, float duration)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			if ((int)Plugin.Config.HapticFeedback.Value <= (int)type || amplitude < 0f || duration < 0f)
			{
				return;
			}
			InputDevice[] array;
			XRNode val;
			switch (hand)
			{
			case Hand.Both:
				array = (InputDevice[])(object)new InputDevice[2]
				{
					InputDevices.GetDeviceAtXRNode((XRNode)4),
					InputDevices.GetDeviceAtXRNode((XRNode)5)
				};
				break;
			case Hand.Dominant:
				val = (XRNode)(VRSession.IsLeftHanded ? 4 : 5);
				goto IL_00bb;
			case Hand.Secondary:
				val = (XRNode)(VRSession.IsLeftHanded ? 5 : 4);
				goto IL_00bb;
			case Hand.Left:
				val = (XRNode)4;
				goto IL_00bb;
			case Hand.Right:
				val = (XRNode)5;
				goto IL_00bb;
			default:
				{
					throw new ArgumentOutOfRangeException("hand", hand, null);
				}
				IL_00bb:
				array = (InputDevice[])(object)new InputDevice[1] { InputDevices.GetDeviceAtXRNode(val) };
				break;
			}
			CollectionExtensions.Do<InputDevice>((IEnumerable<InputDevice>)array, (Action<InputDevice>)delegate(InputDevice device)
			{
				HapticCapabilities val2 = default(HapticCapabilities);
				if (((InputDevice)(ref device)).isValid && ((InputDevice)(ref device)).TryGetHapticCapabilities(ref val2) && ((HapticCapabilities)(ref val2)).supportsImpulse)
				{
					((InputDevice)(ref device)).SendHapticImpulse(0u, amplitude, duration);
				}
			});
		}

		public static void PulseCurve(Hand hand, AnimationCurveData curve, float amplitude = 0.1f, float speed = 1f, int priority = 1)
		{
			if (priority >= instance.currentPriority)
			{
				instance.currentHand = hand;
				instance.currentCurve = curve;
				instance.currentAmplitude = amplitude;
				instance.curveTimer = 0f;
				instance.curveSpeed = speed;
				instance.currentPriority = priority;
			}
		}

		public static void Impulse(Hand hand, Type type, float amplitude = 0.1f, float duration = 0.1f, int priority = 1)
		{
			if (priority >= instance.currentPriority)
			{
				instance.currentPriority = priority;
				instance.priorityTimer = duration;
				Execute(hand, type, amplitude, duration);
			}
		}
	}
	public class VRSession : MonoBehaviour
	{
		public static VRSession Instance { get; private set; }

		public static bool InVR => Plugin.Flags.HasFlag(Flags.VR);

		public static bool IsLeftHanded => Plugin.Config.LeftHandDominant.Value;

		public Camera MainCamera { get; private set; }

		public VRPlayer Player { get; private set; }

		public GameHud HUD { get; private set; }

		public FocusSphere FocusSphere { get; private set; }

		private void Awake()
		{
			Instance = this;
			if (InVR)
			{
				InitializeVRSession();
			}
		}

		private void OnDestroy()
		{
			Instance = null;
		}

		private void InitializeVRSession()
		{
			GameObject obj = GameObject.Find("EventSystem");
			InputSystemUIInputModule val = ((obj != null) ? obj.GetComponent<InputSystemUIInputModule>() : null);
			if ((Object)(object)val != (Object)null)
			{
				((Behaviour)val).enabled = false;
			}
			MainCamera = CameraUtils.Instance.MainCamera;
			MainCamera.targetTexture = null;
			MainCamera.depth = 0f;
			Camera component = ((Component)((Component)MainCamera).transform.Find("Camera Top")).GetComponent<Camera>();
			component.depth = 1f;
			component.targetTexture = null;
			Player = ((Component)PlayerController.instance).gameObject.AddComponent<VRPlayer>();
			HUD = ((Component)HUD.instance).gameObject.AddComponent<GameHud>();
			VRMapTool.Create();
			FocusSphere = Object.Instantiate<GameObject>(AssetCollection.FocusSphere, ((Component)MainCamera).transform.parent).GetComponent<FocusSphere>();
		}
	}
}
namespace RepoXR.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; }

		public InputAction EyeGazePosition { get; private set; }

		public InputAction EyeGazeRotation { get; private set; }

		public InputAction this[string name] => VRInputSystem.Instance.Actions[name];

		private Actions()
		{
			HeadPosition = AssetCollection.DefaultXRActions.FindAction("Head/Position", false);
			HeadRotation = AssetCollection.DefaultXRActions.FindAction("Head/Rotation", false);
			HeadTrackingState = AssetCollection.DefaultXRActions.FindAction("Head/Tracking State", false);
			LeftHandPosition = AssetCollection.DefaultXRActions.FindAction("Left/Position", false);
			LeftHandRotation = AssetCollection.DefaultXRActions.FindAction("Left/Rotation", false);
			LeftHandTrackingState = AssetCollection.DefaultXRActions.FindAction("Left/Tracking State", false);
			RightHandPosition = AssetCollection.DefaultXRActions.FindAction("Right/Position", false);
			RightHandRotation = AssetCollection.DefaultXRActions.FindAction("Right/Rotation", false);
			RightHandTrackingState = AssetCollection.DefaultXRActions.FindAction("Right/Tracking State", false);
			EyeGazePosition = AssetCollection.DefaultXRActions.FindAction("Eye Gaze/Position", false);
			EyeGazeRotation = AssetCollection.DefaultXRActions.FindAction("Eye Gaze/Rotation", false);
			AssetCollection.DefaultXRActions.Enable();
		}
	}
	public class RebindManager : MonoBehaviour
	{
		private readonly string[] DISALLOWED_BINDINGS = new string[23]
		{
			"<WMRSpatialController>/touchpadTouched", "<OculusTouchController>/primaryTouched", "<OculusTouchController>/secondaryTouched", "<OculusTouchController>/triggerTouched", "<OculusTouchController>/thumbstickTouched", "<ViveController>/trackpadTouched", "<ValveIndexController>/systemTouched", "<ValveIndexController>/primaryTouched", "<ValveIndexController>/secondaryTouched", "<ValveIndexController>/gripForce",
			"<ValveIndexController>/triggerTouched", "<ValveIndexController>/thumbstickTouched", "<ValveIndexController>/trackpadTouched", "<ValveIndexController>/trackpadForce", "<QuestProTouchController>/primaryTouched", "<QuestProTouchController>/secondaryTouched", "<QuestProTouchController>/triggerTouched", "<QuestProTouchController>/thumbstickTouched", "<QuestProTouchController>/triggerCurl", "<QuestProTouchController>/triggerSlide",
			"<QuestProTouchController>/triggerProximity", "<QuestProTouchController>/thumbProximity", "*/isTracked"
		};

		private PlayerInput playerInput;

		private RebindingOperation? currentOperation;

		private ControlOption currentOption;

		private readonly List<ControlOption> options = new List<ControlOption>();

		private float lastRebindTime;

		public static RebindManager Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
			playerInput = VRInputSystem.Instance.GetPlayerInput();
			DestroyOldUI();
			CreateUI();
			playerInput.onControlsChanged += OnControlsChanged;
			ReloadBindings();
		}

		private void OnDestroy()
		{
			playerInput.onControlsChanged -= OnControlsChanged;
		}

		private void OnControlsChanged(PlayerInput input)
		{
			Logger.LogDebug("New control scheme: " + input.currentControlScheme);
			ReloadBindings();
		}

		private void DestroyOldUI()
		{
			Transform val = ((Component)this).transform.Find("Scroll Box/Mask/Scroller");
			List<GameObject> list = new List<GameObject>();
			for (int i = 3; i < val.childCount; i++)
			{
				list.Add(((Component)val.GetChild(i)).gameObject);
			}
			list.ForEach((Action<GameObject>)Object.DestroyImmediate);
		}

		private void CreateUI()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ((Component)this).transform.Find("Scroll Box/Mask/Scroller");
			int num = -40;
			RemappableControl[] controls = AssetCollection.RemappableControls.controls;
			foreach (RemappableControl remappableControl in controls)
			{
				if (!string.IsNullOrEmpty(remappableControl.headerName))
				{
					num -= 10;
					RectTransform component = Object.Instantiate<GameObject>(AssetCollection.RebindHeader, val).GetComponent<RectTransform>();
					((Transform)component).localPosition = new Vector3(58.8f, (float)num, 0f);
					((TMP_Text)((Component)component).GetComponentInChildren<TextMeshProUGUI>()).text = remappableControl.headerName;
					num -= 58;
				}
				RectTransform component2 = Object.Instantiate<GameObject>(remappableControl.toggleable ? AssetCollection.RebindButtonToggle : AssetCollection.RebindButton, val).GetComponent<RectTransform>();
				ControlOption component3 = ((Component)component2).GetComponent<ControlOption>();
				((Transform)component2).localPosition = new Vector3(0f, (float)num, 0f);
				component3.Setup(this, remappableControl);
				options.Add(component3);
				num -= (remappableControl.toggleable ? 65 : 42);
			}
		}

		public void StartRebind(ControlOption option, int bindingIndex)
		{
			ControlOption option2 = option;
			if (Time.realtimeSinceStartup - lastRebindTime < 0.5f || string.IsNullOrEmpty(playerInput.currentControlScheme))
			{
				return;
			}
			if (currentOperation != null)
			{
				currentOperation.Dispose();
				if ((Object)(object)currentOption != (Object)null)
				{
					currentOption.ReloadBinding();
				}
			}
			option2.StartRebindTimer();
			playerInput.DeactivateInput();
			currentOption = option2;
			currentOperation = InputActionRebindingExtensions.PerformInteractiveRebinding(option2.action, bindingIndex).OnMatchWaitForAnother(0.1f).WithControlsHavingToMatchPath("<XRController>")
				.WithTimeout(5f)
				.OnComplete((Action<RebindingOperation>)delegate
				{
					CompleteRebind(option2);
				})
				.OnCancel((Action<RebindingOperation>)delegate
				{
					CompleteRebind(option2);
				});
			string[] dISALLOWED_BINDINGS = DISALLOWED_BINDINGS;
			foreach (string text in dISALLOWED_BINDINGS)
			{
				currentOperation.WithControlsExcluding(text);
			}
			currentOperation.Start();
		}

		public void SaveBindings()
		{
			if (VRSession.IsLeftHanded)
			{
				Plugin.Config.ControllerBindingsOverrideLeft.Value = InputActionRebindingExtensions.SaveBindingOverridesAsJson((IInputActionCollection2)(object)playerInput.actions);
			}
			else
			{
				Plugin.Config.ControllerBindingsOverride.Value = InputActionRebindingExtensions.SaveBindingOverridesAsJson((IInputActionCollection2)(object)playerInput.actions);
			}
		}

		private void CompleteRebind(ControlOption option)
		{
			RebindingOperation? obj = currentOperation;
			if (obj != null)
			{
				obj.Dispose();
			}
			currentOperation = null;
			playerInput.ActivateInput();
			option.ReloadBinding();
			SaveBindings();
			lastRebindTime = Time.realtimeSinceStartup;
		}

		public void ResetControls()
		{
			InputActionRebindingExtensions.RemoveAllBindingOverrides((IInputActionCollection2)(object)playerInput.actions);
			SaveBindings();
			ReloadBindings();
		}

		private void ReloadBindings()
		{
			foreach (ControlOption option in options)
			{
				option.ReloadBinding();
			}
			if (Object.op_Implicit((Object)(object)MenuPageLobby.instance))
			{
				MenuPageLobby.instance.UpdateChatPrompt();
			}
		}
	}
	public class RemappableControls : MonoBehaviour
	{
		public RemappableControl[] controls;

		public InputActionReference[] additionalBindings;

		public string defaultLeftHandedBindings;
	}
	[Serializable]
	public class RemappableControl
	{
		public string controlName;

		public string headerName;

		public InputActionReference currentInput;

		public int bindingIndex = -1;

		public bool toggleable;

		public bool defaultToggle;
	}
	public class TrackingInput : MonoBehaviour
	{
		private static TrackingInput? _instance;

		public static TrackingInput Instance => _instance ?? ((Component)InputManager.instance).gameObject.AddComponent<TrackingInput>();

		public Transform HeadTransform { get; private set; }

		public Transform LeftHandTransform { get; private set; }

		public Transform RightHandTransform { get; private set; }

		private void Awake()
		{
			if ((Object)(object)_instance != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			_instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			CreateTrackingOrigins();
		}

		private void CreateTrackingOrigins()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			//IL_0123: 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_0142: Expected O, but got Unknown
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Expected O, but got Unknown
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: 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_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Tracking - Head");
			val.transform.parent = ((Component)this).transform;
			HeadTransform = val.transform;
			GameObject val2 = new GameObject("Tracking - Left Hand");
			val2.transform.parent = ((Component)this).transform;
			LeftHandTransform = val2.transform;
			GameObject val3 = new GameObject("Tracking - Right Hand");
			val3.transform.parent = ((Component)this).transform;
			RightHandTransform = val3.transform;
			TrackedPoseDriver val4 = ((Component)HeadTransform).gameObject.AddComponent<TrackedPoseDriver>();
			TrackedPoseDriver val5 = ((Component)LeftHandTransform).gameObject.AddComponent<TrackedPoseDriver>();
			TrackedPoseDriver val6 = ((Component)RightHandTransform).gameObject.AddComponent<TrackedPoseDriver>();
			val4.positionAction = new InputAction((string)null, (InputActionType)0, "<XRHMD>/centerEyePosition", (string)null, (string)null, (string)null);
			val4.rotationAction = new InputAction((string)null, (InputActionType)0, "<XRHMD>/centerEyeRotation", (string)null, (string)null, (string)null);
			val4.trackingStateInput = new InputActionProperty(new InputAction((string)null, (InputActionType)0, "<XRHMD>/trackingState", (string)null, (string)null, (string)null));
			val5.positionAction = new InputAction((string)null, (InputActionType)0, "<XRController>{LeftHand}/pointerPosition", (string)null, (string)null, (string)null);
			val5.rotationAction = new InputAction((string)null, (InputActionType)0, "<XRController>{LeftHand}/pointerRotation", (string)null, (string)null, (string)null);
			val5.trackingStateInput = new InputActionProperty(new InputAction((string)null, (InputActionType)0, "<XRController>{LeftHand}/trackingState", (string)null, (string)null, (string)null));
			val6.positionAction = new InputAction((string)null, (InputActionType)0, "<XRController>{RightHand}/pointerPosition", (string)null, (string)null, (string)null);
			val6.rotationAction = new InputAction((string)null, (InputActionType)0, "<XRController>{RightHand}/pointerRotation", (string)null, (string)null, (string)null);
			val6.trackingStateInput = new InputActionProperty(new InputAction((string)null, (InputActionType)0, "<XRController>{RightHand}/trackingState", (string)null, (string)null, (string)null));
			val4.positionAction.Enable();
			val4.rotationAction.Enable();
			InputActionProperty trackingStateInput = val4.trackingStateInput;
			((InputActionProperty)(ref trackingStateInput)).action.Enable();
			val5.positionAction.Enable();
			val5.rotationAction.Enable();
			trackingStateInput = val5.trackingStateInput;
			((InputActionProperty)(ref trackingStateInput)).action.Enable();
			val6.positionAction.Enable();
			val6.rotationAction.Enable();
			trackingStateInput = val6.trackingStateInput;
			((InputActionProperty)(ref trackingStateInput)).action.Enable();
		}
	}
	public class VRInputSystem : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <HoldTimer>d__17 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public VRInputSystem <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <HoldTimer>d__17(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Expected O, but got Unknown
				int num = <>1__state;
				VRInputSystem vRInputSystem = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.3f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!vRInputSystem.playerInput.actions["Chat"].IsPressed())
					{
						return false;
					}
					vRInputSystem.chatHoldTriggered = true;
					vRInputSystem.chatChoice = 2;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static VRInputSystem? _instance;

		private PlayerInput playerInput;

		private Dictionary<string, bool> inputToggle = new Dictionary<string, bool>();

		private Coroutine? chatHoldCoroutine;

		private bool chatHoldTriggered;

		private int chatChoice;

		public static VRInputSystem Instance => _instance ?? ((Component)InputManager.instance).gameObject.AddComponent<VRInputSystem>();

		public InputActionAsset Actions => playerInput.actions;

		public string CurrentControlScheme => playerInput.currentControlScheme;

		private void Awake()
		{
			_instance = this;
			playerInput = ((Component)this).gameObject.AddComponent<PlayerInput>();
			playerInput.actions = AssetCollection.VRInputs;
			playerInput.defaultActionMap = "VR Actions";
			playerInput.defaultControlScheme = "Oculus";
			playerInput.neverAutoSwitchControlSchemes = false;
			playerInput.notificationBehavior = (PlayerNotifications)3;
			if (VRSession.IsLeftHanded)
			{
				InputActionRebindingExtensions.LoadBindingOverridesFromJson((IInputActionCollection2)(object)playerInput.actions, AssetCollection.RemappableControls.defaultLeftHandedBindings, true);
				InputActionRebindingExtensions.LoadBindingOverridesFromJson((IInputActionCollection2)(object)playerInput.actions, Plugin.Config.ControllerBindingsOverrideLeft.Value, false);
			}
			else
			{
				InputActionRebindingExtensions.LoadBindingOverridesFromJson((IInputActionCollection2)(object)playerInput.actions, Plugin.Config.ControllerBindingsOverride.Value, true);
			}
			playerInput.ActivateInput();
			inputToggle = JsonConvert.DeserializeObject<Dictionary<string, bool>>(Plugin.Config.InputToggleBindings.Value) ?? new Dictionary<string, bool>();
		}

		private void OnEnable()
		{
			playerInput.actions["Chat"].performed += ChatPerformed;
			playerInput.actions["Chat"].canceled += ChatCanceled;
			Plugin.Config.LeftHandDominant.SettingChanged += DominantHandChanged;
		}

		private void OnDisable()
		{
			playerInput.actions["Chat"].performed -= ChatPerformed;
			playerInput.actions["Chat"].canceled -= ChatCanceled;
			Plugin.Config.LeftHandDominant.SettingChanged -= DominantHandChanged;
		}

		private void ChatPerformed(CallbackContext context)
		{
			if ((!Object.op_Implicit((Object)(object)ExpressionRadial.instance) || (!ExpressionRadial.instance.isActive && !ExpressionRadial.instance.closedLastPress)) && (SemiFunc.MenuLevel() || !Object.op_Implicit((Object)(object)MenuManager.instance.currentMenuPage)))
			{
				chatHoldTriggered = false;
				chatHoldCoroutine = ((MonoBehaviour)this).StartCoroutine(HoldTimer());
			}
		}

		private void ChatCanceled(CallbackContext context)
		{
			if (Object.op_Implicit((Object)(object)ExpressionRadial.instance) && (ExpressionRadial.instance.isActive || ExpressionRadial.instance.closedLastPress))
			{
				ExpressionRadial.instance.closedLastPress = false;
			}
			else if (SemiFunc.MenuLevel() || !Object.op_Implicit((Object)(object)MenuManager.instance.currentMenuPage))
			{
				if (chatHoldCoroutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(chatHoldCoroutine);
					chatHoldCoroutine = null;
				}
				if (chatHoldTriggered)
				{
					chatHoldTriggered = false;
				}
				else
				{
					chatChoice = 1;
				}
			}
		}

		[IteratorStateMachine(typeof(<HoldTimer>d__17))]
		private IEnumerator HoldTimer()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <HoldTimer>d__17(0)
			{
				<>4__this = this
			};
		}

		public bool ChatPressed()
		{
			if (chatChoice != 1)
			{
				return false;
			}
			chatChoice = 0;
			return true;
		}

		public bool ExpressionPressed()
		{
			if (chatChoice != 2)
			{
				return false;
			}
			chatChoice = 0;
			return true;
		}

		public void ActivateInput()
		{
			playerInput.ActivateInput();
		}

		public void DeactivateInput()
		{
			playerInput.DeactivateInput();
		}

		public PlayerInput GetPlayerInput()
		{
			return playerInput;
		}

		public void InputToggleRebind(string inputAction, bool toggle)
		{
			inputToggle[inputAction] = toggle;
			SaveInputToggles();
		}

		public bool InputToggleGet(string action)
		{
			if (inputToggle.TryGetValue(action, out var value))
			{
				return value;
			}
			RemappableControl[] controls = AssetCollection.RemappableControls.controls;
			foreach (RemappableControl remappableControl in controls)
			{
				if (remappableControl.currentInput.action.name == action)
				{
					inputToggle[action] = remappableControl.defaultToggle;
					return remappableControl.defaultToggle;
				}
			}
			return false;
		}

		private void SaveInputToggles()
		{
			Plugin.Config.InputToggleBindings.Value = JsonConvert.SerializeObject((object)inputToggle);
		}

		private void DominantHandChanged(object sender, EventArgs e)
		{
			if (VRSession.IsLeftHanded)
			{
				InputActionRebindingExtensions.LoadBindingOverridesFromJson((IInputActionCollection2)(object)playerInput.actions, AssetCollection.RemappableControls.defaultLeftHandedBindings, true);
				InputActionRebindingExtensions.LoadBindingOverridesFromJson((IInputActionCollection2)(object)playerInput.actions, Plugin.Config.ControllerBindingsOverrideLeft.Value, false);
			}
			else
			{
				InputActionRebindingExtensions.LoadBindingOverridesFromJson((IInputActionCollection2)(object)playerInput.actions, Plugin.Config.ControllerBindingsOverride.Value, true);
			}
		}
	}
}
namespace RepoXR.Data
{
	public class AnimationCurveData : ScriptableObject
	{
		private static Dictionary<AnimationCurveData, float> curveTimers = new Dictionary<AnimationCurveData, float>();

		public AnimationCurve curve;

		public float Evaluate(float value)
		{
			return curve.Evaluate(value);
		}

		public float EvaluateTimed(float speed = 1f, float length = 1f)
		{
			if (!curveTimers.TryGetValue(this, out var value))
			{
				curveTimers[this] = 0f;
				value = 0f;
			}
			value += Time.deltaTime * speed;
			value = Mathf.Repeat(value, length);
			curveTimers[this] = value;
			return Evaluate(value);
		}

		public void Pulse(HapticManager.Hand hand, float amplitude = 0.1f, float speed = 1f, int priority = 1)
		{
			HapticManager.PulseCurve(hand, this, amplitude, speed, priority);
		}
	}
	public class OpenXRFeaturePack : ScriptableObject
	{
		[SerializeReference]
		private List<OpenXRFeature> features = new List<OpenXRFeature>();

		public IReadOnlyList<OpenXRFeature> Features => features;
	}
}
namespace RepoXR.Assets
{
	internal static class AssetCollection
	{
		private static AssetBundle assetBundle;

		public static OpenXRFeaturePack OpenXRFeatures;

		public static RemappableControls RemappableControls;

		public static GameObject RebindHeader;

		public static GameObject RebindButton;

		public static GameObject RebindButtonToggle;

		public static GameObject VRRig;

		public static GameObject CustomCamera;

		public static GameObject VRTumble;

		public static GameObject Keyboard;

		public static GameObject ExpressionWheel;

		public static GameObject ValuableDiscover;

		public static GameObject FocusSphere;

		public static GameObject MenuSettings;

		public static GameObject MenuSettingsCategory;

		public static GameObject MenuShowcase;

		public static GameObject RuntimeSetting;

		public static GameObject BoolSetting;

		public static GameObject SliderSetting;

		public static GameObject VRSettingsButton;

		public static InputActionAsset DefaultXRActions;

		public static InputActionAsset VRInputs;

		public static Material DefaultLine;

		public static Material VideoOverlay;

		public static TMP_SpriteAsset TMPInputsSpriteAsset;

		public static Sprite Logo;

		public static Shader VignetteShader;

		public static AnimationCurveData OverchargeHapticCurve;

		public static AnimationCurveData GrabberHapticCurve;

		public static AnimationCurveData HurtHapticCurve;

		public static AnimationCurveData EyeAttachHapticCurve;

		public static AnimationCurveData KeyboardAnimation;

		public static GameObject Cube;

		[PublicAPI]
		public static string AddressablesPath => Path.Combine(Path.GetDirectoryName(Plugin.Config.AssemblyPath), "Addressables");

		public static bool LoadAssets()
		{
			//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)
			if (!ValidateFPTSVersion())
			{
				Logger.LogError("Failed to validate FixPluginTypesSerialization version. Make sure that this mod is installed and up-to-date before launching RepoXR.");
				Logger.LogError("In the case that the mod already appears to be up-to-date: uninstall it, clear your mod manager cache, and reinstall it.");
				return false;
			}
			assetBundle = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Plugin.Config.AssemblyPath), "repoxrassets"));
			if ((Object)(object)assetBundle == (Object)null)
			{
				Logger.LogError("Failed to load asset bundle!");
				return false;
			}
			Addressables.LoadContentCatalogAsync(Path.Combine(AddressablesPath, "catalog_0.1.json"), true, (string)null).WaitForCompletion();
			OpenXRFeatures = assetBundle.LoadAsset<OpenXRFeaturePack>("OpenXRFeatures");
			RemappableControls = assetBundle.LoadAsset<GameObject>("RemappableControls").GetComponent<RemappableControls>();
			RebindHeader = assetBundle.LoadAsset<GameObject>("Rebind Header");
			RebindButton = assetBundle.LoadAsset<GameObject>("Rebind Button");
			RebindButtonToggle = assetBundle.LoadAsset<GameObject>("Rebind Button Toggle");
			VRRig = assetBundle.LoadAsset<GameObject>("VRRig");
			CustomCamera = assetBundle.LoadAsset<GameObject>("Custom Camera");
			VRTumble = assetBundle.LoadAsset<GameObject>("VRTumble");
			Keyboard = assetBundle.LoadAsset<GameObject>("NonNativeKeyboard");
			ExpressionWheel = assetBundle.LoadAsset<GameObject>("Expression Radial");
			ValuableDiscover = assetBundle.LoadAsset<GameObject>("Valuable Discover");
			FocusSphere = assetBundle.LoadAsset<GameObject>("Focus Sphere");
			MenuSettings = assetBundle.LoadAsset<GameObject>("VR Settings Page");
			MenuSettingsCategory = assetBundle.LoadAsset<GameObject>("VR Settings Page - Category");
			MenuShowcase = assetBundle.LoadAsset<GameObject>("VR Showcase Page");
			RuntimeSetting = assetBundle.LoadAsset<GameObject>("Runtime Setting");
			BoolSetting = assetBundle.LoadAsset<GameObject>("Bool Setting");
			SliderSetting = assetBundle.LoadAsset<GameObject>("Slider Setting");
			VRSettingsButton = assetBundle.LoadAsset<GameObject>("VR Settings Button");
			DefaultXRActions = assetBundle.LoadAsset<InputActionAsset>("DefaultXRActions");
			VRInputs = assetBundle.LoadAsset<InputActionAsset>("VRInputs");
			DefaultLine = assetBundle.LoadAsset<Material>("Default-Line");
			VideoOverlay = assetBundle.LoadAsset<Material>("Video Overlay");
			TMPInputsSpriteAsset = assetBundle.LoadAsset<TMP_SpriteAsset>("TMPInputsSpriteAsset");
			Logo = assetBundle.LoadAsset<Sprite>("REPOXR_Splash_Logo");
			VignetteShader = assetBundle.LoadAsset<Shader>("VignetteVR");
			GrabberHapticCurve = assetBundle.LoadAsset<AnimationCurveData>("GrabberHapticCurve");
			OverchargeHapticCurve = assetBundle.LoadAsset<AnimationCurveData>("OverchargeHapticCurve");
			HurtHapticCurve = assetBundle.LoadAsset<AnimationCurveData>("HurtHapticCurve");
			EyeAttachHapticCurve = assetBundle.LoadAsset<AnimationCurveData>("EyeAttachHapticCurve");
			KeyboardAnimation = assetBundle.LoadAsset<AnimationCurveData>("KeyboardAnimation");
			Cube = assetBundle.LoadAsset<GameObject>("JustACube");
			return true;
		}

		public static AsyncOperationHandle<LocalizedAsset> GetLocalizedAsset(string name)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return Addressables.LoadAssetAsync<LocalizedAsset>((object)("LocalizedAsset XR - " + name));
		}

		private static bool ValidateFPTSVersion()
		{
			Assembly assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly asm) => asm.GetName().Name == "FixPluginTypesSerialization");
			if (assembly == null)
			{
				Logger.LogError("FPTS check failed: Assembly missing from AppDomain");
				return false;
			}
			if (assembly.DefinedTypes.Any((TypeInfo type) => type.FullName == "FixPluginTypesSerialization.UnityPlayer.Structs.Default.IIsFileCreatedParam"))
			{
				return true;
			}
			Logger.LogError("FPTS check failed: Missing required interface (mod is outdated)");
			return false;
		}
	}
}