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

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("DaXcess")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) DaXcess 2025")]
[assembly: AssemblyDescription("RepoXR Preloader")]
[assembly: AssemblyFileVersion("1.0.3.0")]
[assembly: AssemblyInformationalVersion("1.0.3+45210b4dece791a1a4b509edf0fdef5e39ebfd0c")]
[assembly: AssemblyProduct("RepoXR.Preload")]
[assembly: AssemblyTitle("RepoXR.Preload")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/DaXcess/RepoXR")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.3.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace RepoXR.Preload
{
	public static class Preload
	{
		private const string VR_MANIFEST = "{\n  \"name\": \"OpenXR XR Plugin\",\n  \"version\": \"1.10.0\",\n  \"libraryName\": \"UnityOpenXR\",\n  \"displays\": [\n    {\n      \"id\": \"OpenXR Display\"\n    }\n  ],\n  \"inputs\": [\n    {\n      \"id\": \"OpenXR Input\"\n    }\n  ]\n}";

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

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


		public static void Initialize()
		{
			Logger.LogInfo((object)"Setting up VR runtime assets");
			SetupRuntimeAssets();
			Logger.LogInfo((object)"We're done here. Goodbye!");
		}

		private static void SetupRuntimeAssets()
		{
			string path = Path.Combine(Paths.GameRootPath, "REPO_Data");
			string text = Path.Combine(path, "UnitySubsystems");
			if (!Directory.Exists(text))
			{
				Directory.CreateDirectory(text);
			}
			string text2 = Path.Combine(text, "UnityOpenXR");
			if (!Directory.Exists(text2))
			{
				Directory.CreateDirectory(text2);
			}
			string path2 = Path.Combine(text2, "UnitySubsystemsManifest.json");
			if (!File.Exists(path2))
			{
				File.WriteAllText(path2, "{\n  \"name\": \"OpenXR XR Plugin\",\n  \"version\": \"1.10.0\",\n  \"libraryName\": \"UnityOpenXR\",\n  \"displays\": [\n    {\n      \"id\": \"OpenXR Display\"\n    }\n  ],\n  \"inputs\": [\n    {\n      \"id\": \"OpenXR Input\"\n    }\n  ]\n}");
			}
			string path3 = Path.Combine(path, "Plugins");
			string destFileName = Path.Combine(path3, "UnityOpenXR.dll");
			string destFileName2 = Path.Combine(path3, "openxr_loader.dll");
			string? directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			string sourceFileName = Path.Combine(directoryName, "RuntimeDeps/UnityOpenXR.dll");
			string sourceFileName2 = Path.Combine(directoryName, "RuntimeDeps/openxr_loader.dll");
			File.Copy(sourceFileName, destFileName, overwrite: true);
			File.Copy(sourceFileName2, destFileName2, overwrite: true);
		}

		public static void Patch(AssemblyDefinition assembly)
		{
		}
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
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.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.UI;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.InputSystem.XR;
using UnityEngine.Rendering;
using UnityEngine.Rendering.PostProcessing;
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;
using UnityEngine.XR.OpenXR.Features.Interactions;

[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 2025")]
[assembly: AssemblyDescription("Collecting Valuables in VR")]
[assembly: AssemblyFileVersion("1.0.3.0")]
[assembly: AssemblyInformationalVersion("1.0.3+45210b4dece791a1a4b509edf0fdef5e39ebfd0c")]
[assembly: AssemblyProduct("RepoXR")]
[assembly: AssemblyTitle("RepoXR")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/DaXcess/RepoXR")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.3.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.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;
		}
	}
}
namespace RepoXR
{
	public static class Compat
	{
		public const string UnityExplorer = "com.sinai.unityexplorer";

		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
		}

		private static bool leftHandedWarningShown;

		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(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(null, false, 1f, 1f, "", "On", "Off", false)]
		public ConfigEntry<HapticFeedbackOption> HapticFeedback { get; }

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

		[ConfigDescriptor(null, 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, 5f, 1f, "%", "On", "Off", false)]
		public ConfigEntry<int> CameraResolution { 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> DynamicSmoothSpeed { 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> Vignette { get; }

		[ConfigDescriptor(null, false, 1f, 1f, "", "On", "Off", false)]
		public ConfigEntry<bool> CustomCamera { 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> InputToggleBindings { get; }

		public ConfigEntry<string> OpenXRRuntimeFile { get; }

		public Config(string assemblyPath, ConfigFile file)
		{
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: 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_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Expected O, but got Unknown
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Expected O, but got Unknown
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Expected O, but got Unknown
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Expected O, but got Unknown
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Expected O, but got Unknown
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Expected O, but got Unknown
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Expected O, but got Unknown
			AssemblyPath = assemblyPath;
			File = file;
			DisableVR = file.Bind<bool>("General", "DisableVR", false, "Disables the main functionality of this mod, can be used if you want to play without VR while keeping the mod installed.");
			VerboseLogging = file.Bind<bool>("General", "VerboseLogging", false, "Enables verbose debug logging during OpenXR initialization");
			ReducedAimImpact = file.Bind<bool>("Gameplay", "ReducedAimImpact", 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.Bind<bool>("Gameplay", "RoomscaleCrouch", true, "When enabled, allows for the player to physically crouch to also crouch in-game");
			LeftHandDominant = file.Bind<bool>("Gameplay", "LeftHandDominant", false, "Whether to use the left or right hand as dominant hand (the hand used to pick up items)");
			HapticFeedback = file.Bind<HapticFeedbackOption>("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>()));
			HUDPlaneOffset = file.Bind<float>("Gameplay", "HUDPlaneOffset", -0.45f, new ConfigDescription("The default height offset for the HUD", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-0.6f, 0.5f), Array.Empty<object>()));
			HUDGazePlaneOffset = file.Bind<float>("Gameplay", "HUDGazePlaneOffset", -0.25f, new ConfigDescription("The height offset for the HUD when looking at it", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-0.6f, 0.5f), Array.Empty<object>()));
			SmoothCanvasDistance = file.Bind<float>("Gameplay", "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>()));
			CameraResolution = file.Bind<int>("Performance", "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>()));
			TurnProvider = file.Bind<TurnProviderOption>("Input", "TurnProvider", TurnProviderOption.Smooth, new ConfigDescription("Specify which turning provider your player uses, if any.", (AcceptableValueBase)(object)new AcceptableValueEnum<TurnProviderOption>(), Array.Empty<object>()));
			SmoothTurnSpeedModifier = file.Bind<float>("Input", "SmoothTurnSpeedModifier", 1f, new ConfigDescription("A multiplier that is added to the smooth turning speed. Requires turn provider to be set to smooth.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 5f), Array.Empty<object>()));
			DynamicSmoothSpeed = file.Bind<bool>("Input", "DynamicSmoothSpeed", true, "When enabled, makes the speed of the smooth turning dependent on how far the analog stick is pushed.");
			SnapTurnSize = file.Bind<float>("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>()));
			Vignette = file.Bind<bool>("Rendering", "Vignette", true, "Enables the vignette shader used in certain scenarios and levels in the game.");
			CustomCamera = file.Bind<bool>("Rendering", "CustomCamera", 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!");
			CustomCameraFOV = file.Bind<float>("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.Bind<float>("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.Bind<string>("Internal", "ControllerBindingsOverride", "", "FOR INTERNAL USE ONLY, DO NOT EDIT");
			InputToggleBindings = file.Bind<string>("Internal", "InputToggleBindings", "", "FOR INTERNAL USE ONLY, DO NOT EDIT");
			OpenXRRuntimeFile = file.Bind<string>("Internal", "OpenXRRuntimeFile", "", "FOR INTERNAL USE ONLY, DO NOT EDIT");
			base..ctor();
		}

		public void SetupGlobalCallbacks()
		{
			if (!VRSession.InVR)
			{
				return;
			}
			CameraResolution.SettingChanged += delegate
			{
				XRSettings.eyeTextureResolutionScale = (float)CameraResolution.Value / 100f;
			};
			CustomCamera.SettingChanged += delegate
			{
				if (CustomCamera.Value)
				{
					Object.Instantiate<GameObject>(AssetCollection.CustomCamera, ((Component)Camera.main).transform.parent);
				}
				else
				{
					Object.Destroy((Object)(object)((Component)VRCustomCamera.instance).gameObject);
				}
			};
			LeftHandDominant.SettingChanged += delegate
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				if (LeftHandDominant.Value && !leftHandedWarningShown)
				{
					leftHandedWarningShown = true;
					MenuManager.instance.PagePopUpScheduled("Left Handed Notice", Color.yellow, "Left handed mode does not change your default bindings. To set up proper bindings for left handed mode, change your bindings by going to\nSettings -> Controls", "Will do", false);
					MenuManager.instance.PagePopUpScheduledShow();
				}
			};
		}
	}
	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();
		}
	}
	[RepoXRPatch(RepoXRPatchTarget.VROnly, null)]
	internal static class Entrypoint
	{
		private static bool hasShownErrorMessage;

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

		private static void SetupDefaultSceneVR()
		{
			//IL_00b4: 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_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_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_01f0: 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_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: 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_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: 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_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: 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");
			Camera component = ((Component)transform.parent.Find("Camera Overlay")).GetComponent<Camera>();
			Camera main = Camera.main;
			TrackedPoseDriver obj = ((Component)main).gameObject.AddComponent<TrackedPoseDriver>();
			obj.positionAction = Actions.Instance.HeadPosition;
			obj.rotationAction = Actions.Instance.HeadRotation;
			obj.trackingStateInput = new InputActionProperty(Actions.Instance.HeadTrackingState);
			((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 val6 = new GameObject("VR Overlay Canvas")
			{
				layer = 5
			}.AddComponent<Canvas>();
			val6.renderMode = (RenderMode)1;
			val6.worldCamera = component;
			val6.sortingOrder = 5;
			val.SetParent(((Component)val6).transform, false);
			val2.SetParent(((Component)val6).transform, false);
			((Graphic)((Component)val2).GetComponent<RawImage>()).material = AssetCollection.VideoOverlay;
			CollectionExtensions.Do<RectTransform>((IEnumerable<RectTransform>)((Component)((Component)val6).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 val7 = new GameObject("VR Loading Canvas")
			{
				layer = 5
			}.AddComponent<Canvas>();
			val7.renderMode = (RenderMode)2;
			val7.sortingOrder = 6;
			((Component)val7).transform.localPosition = Vector3.zero;
			((Component)val7).transform.localEulerAngles = Vector3.zero;
			((Component)val7).transform.localScale = Vector3.one * 0.01f;
			((Component)val7).transform.SetParent(((Component)Camera.main).transform.parent, false);
			((Component)val7).gameObject.AddComponent<LoadingUI>();
			((Component)val7).GetComponent<RectTransform>().sizeDelta = new Vector2(720f, 400f);
			val3.SetParent(((Component)val7).transform, false);
			GameObject val8 = new GameObject("Moon Mask");
			val8.transform.parent = ((Component)val7).transform;
			val8.transform.localScale = Vector3.one;
			val8.transform.localPosition = Vector3.zero;
			val8.transform.localRotation = Quaternion.identity;
			RectTransform component2 = ((Component)val8.AddComponent<RectMask2D>()).GetComponent<RectTransform>();
			component2.sizeDelta = new Vector2(800f, 550f);
			val4.SetParent(((Component)component2).transform, false);
			val4.localScale = Vector3.one * 0.8f;
			val5.SetParent(((Component)val7).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>();
		}

		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();
		}

		[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)
		{
			string name = ((Object)__instance).name;
			if ((!(name == "Start Room - Main Menu(Clone)") && !(name == "Start Room - Lobby Menu(Clone)")) || 1 == 0)
			{
				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>();
		}

		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 can disable VR in the settings if you are not planning to play in VR.", "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 bool ShowWindow(IntPtr hWnd, int nCmdShow);

		[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;
				if (OpenXRSettings.Instance.features.Length == 0)
				{
					ValveIndexControllerProfile val = ScriptableObject.CreateInstance<ValveIndexControllerProfile>();
					HPReverbG2ControllerProfile val2 = ScriptableObject.CreateInstance<HPReverbG2ControllerProfile>();
					HTCViveControllerProfile val3 = ScriptableObject.CreateInstance<HTCViveControllerProfile>();
					MicrosoftMotionControllerProfile val4 = ScriptableObject.CreateInstance<MicrosoftMotionControllerProfile>();
					KHRSimpleControllerProfile val5 = ScriptableObject.CreateInstance<KHRSimpleControllerProfile>();
					MetaQuestTouchProControllerProfile val6 = ScriptableObject.CreateInstance<MetaQuestTouchProControllerProfile>();
					OculusTouchControllerProfile val7 = ScriptableObject.CreateInstance<OculusTouchControllerProfile>();
					((OpenXRFeature)val).enabled = true;
					((OpenXRFeature)val2).enabled = true;
					((OpenXRFeature)val3).enabled = true;
					((OpenXRFeature)val4).enabled = true;
					((OpenXRFeature)val5).enabled = true;
					((OpenXRFeature)val6).enabled = true;
					((OpenXRFeature)val7).enabled = true;
					OpenXRSettings.Instance.features = (OpenXRFeature[])(object)new OpenXRFeature[7]
					{
						(OpenXRFeature)val,
						(OpenXRFeature)val2,
						(OpenXRFeature)val3,
						(OpenXRFeature)val4,
						(OpenXRFeature)val5,
						(OpenXRFeature)val6,
						(OpenXRFeature)val7
					};
				}
			}
		}

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

		private static IEnumerable<Runtime> LocateCommonRuntimes()
		{
			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)
			{
				yield return runtime.Value;
			}
			string path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "Virtual Desktop Streamer\\OpenXR\\virtualdesktop-openxr.json");
			if (File.Exists(path) && Runtime.ReadFromJson(path, out var runtime2))
			{
				yield return runtime2;
			}
			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))
			{
				yield return runtime2;
			}
		}

		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.0.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.0.2";

		private const string SKIP_CHECKSUM_VAR = "--repoxr-skip-checksum=1.0.2";

		private const string HASHES_OVERRIDE_URL = "https://gist.githubusercontent.com/DaXcess/033e8ff514c505d2372e6f55a412dc00/raw/RepoXR%2520Game%2520Hashes";

		private readonly string[] GAME_ASSEMBLY_HASHES = new string[1] { "E95BEFC4BD5206D9455BAA68C51A950ABAF0A99001012928B3E553D8D0E5CDB3" };

		public static Config Config { get; private set; }

		public static Flags Flags { get; private set; }

		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.0.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");
			}
			bool flag2 = Environment.GetCommandLineArgs().Contains("--repoxr-skip-checksum=1.0.2");
			if (!VerifyGameVersion())
			{
				if (!flag2)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)"Error: Unsupported game version, or corrupted game detected!");
					((BaseUnityPlugin)this).Logger.LogError((object)"RepoXR only supports legitimate Steam copies of R.E.P.O.");
					((BaseUnityPlugin)this).Logger.LogError((object)"R.E.P.O. might have been updated recently, which will also trigger this error.");
					((BaseUnityPlugin)this).Logger.LogDebug((object)"To bypass this check, add the following flag to your launch options in Steam: --repoxr-skip-checksum=1.0.2");
					return;
				}
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Warning: Unsupported game version, or corrupted game detected!");
				((BaseUnityPlugin)this).Logger.LogWarning((object)"RepoXR might not work properly. Please consider updating your game and RepoXR before creating bug reports.");
			}
			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();
			((BaseUnityPlugin)this).Logger.LogDebug((object)"Inserted universal patches using Harmony");
			Native.BringGameWindowToFront();
			Config.SetupGlobalCallbacks();
			SceneManager.sceneLoaded += delegate(Scene scene, LoadSceneMode _)
			{
				Entrypoint.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 VerifyGameVersion()
		{
			string text = BitConverter.ToString(Utils.ComputeHash(File.ReadAllBytes(Path.Combine(Paths.ManagedPath, "Assembly-CSharp.dll")))).Replace("-", "");
			if (GAME_ASSEMBLY_HASHES.Contains(text))
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Game version verified using local hashes");
				return true;
			}
			((BaseUnityPlugin)this).Logger.LogWarning((object)"Failed to verify game version using local hashes, checking remotely for updated hashes...");
			try
			{
				string[] array = Utils.ParseConfig(new WebClient().DownloadString("https://gist.githubusercontent.com/DaXcess/033e8ff514c505d2372e6f55a412dc00/raw/RepoXR%2520Game%2520Hashes"));
				bool flag = false;
				string[] array2 = array;
				foreach (string text2 in array2)
				{
					try
					{
						string[] array3 = text2.Split(':');
						(string[], string) valueTuple = (array3[0].Split(','), array3[1]);
						var (source, _) = valueTuple;
						if (valueTuple.Item2 != text || !source.Contains("1.0.2"))
						{
							continue;
						}
						flag = true;
						break;
					}
					catch
					{
					}
				}
				if (!flag)
				{
					return false;
				}
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Game version verified using remote hashes");
				return true;
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Failed to verify using remote hashes: " + ex.Message));
				return false;
			}
		}

		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);
					if ((!(fileName == "UnityOpenXR.dll") && !(fileName == "openxr_loader.dll")) || 1 == 0)
					{
						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.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
	}
	internal static class Utils
	{
		public static byte[] ComputeHash(byte[] input)
		{
			using SHA256 sHA = SHA256.Create();
			return sHA.ComputeHash(input);
		}

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

		public static string 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, Collider rhs)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = default(Vector3);
			float num = default(float);
			return Physics.ComputePenetration(lhs, ((Component)lhs).transform.position, ((Component)lhs).transform.rotation, rhs, ((Component)rhs).transform.position, ((Component)rhs).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;
		}
	}
}
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_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: 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_019a: 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_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(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 GameHud : MonoBehaviour
	{
		private Transform smoothCanvasContainer;

		private Transform camera;

		private PauseUI pause;

		public Canvas OverlayCanvas { get; private set; }

		public Canvas SmoothedCanvas { get; private set; }

		private IEnumerator Start()
		{
			yield return null;
			camera = ((Component)CameraOverlay.instance.overlayCamera).transform;
			DisableEventSystem();
			SetupOverlayCanvas();
			SetupSmoothedCanvas();
			SetupPauseMenu();
			SetupInfoHUD();
			((Component)HUDCanvas.instance).transform.position = Vector3.down * 10000f;
		}

		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_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)
			//IL_0068: 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_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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00a1: 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_00cc: 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 + 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 obj = ((Component)HUDCanvas.instance).transform.Find("HUD/Chat Local");
			val3.SetParent((Transform)(object)component, false);
			obj.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_00fe: 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_011e: 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_0148: 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>();
			((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.DisableScanlines();
			component2.DisableScanlines();
			component3.DisableScanlines();
			component4.DisableScanlines();
			component5.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));
		}
	}
	public class LoadingUI : MonoBehaviour
	{
		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;
		}

		private IEnumerator Start()
		{
			RestorePosition();
			yield return null;
			RestorePosition();
		}

		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