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

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = "")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
internal static class GameFolderRedirect
{
	[UnmanagedFunctionPointer(CallingConvention.Winapi, SetLastError = true)]
	private delegate IntPtr CreateFileWFn(IntPtr name, uint access, uint share, IntPtr security, uint disposition, uint flags, IntPtr template);

	[UnmanagedFunctionPointer(CallingConvention.Winapi, SetLastError = true)]
	private delegate uint GetFileAttributesWFn(IntPtr name);

	[UnmanagedFunctionPointer(CallingConvention.Winapi, SetLastError = true)]
	private delegate int GetFileAttributesExWFn(IntPtr name, int level, IntPtr info);

	[UnmanagedFunctionPointer(CallingConvention.Winapi, SetLastError = true)]
	private delegate IntPtr FindFirstFileWFn(IntPtr name, IntPtr data);

	[UnmanagedFunctionPointer(CallingConvention.Winapi, SetLastError = true)]
	private delegate IntPtr FindFirstFileExWFn(IntPtr name, int level, IntPtr data, int op, IntPtr filter, uint flags);

	[UnmanagedFunctionPointer(CallingConvention.Winapi, SetLastError = true)]
	private delegate IntPtr LoadLibraryWFn(IntPtr name);

	[UnmanagedFunctionPointer(CallingConvention.Winapi, SetLastError = true)]
	private delegate IntPtr LoadLibraryExWFn(IntPtr name, IntPtr file, uint flags);

	private const int MaxLoggedRedirects = 60;

	private static readonly ManualLogSource Log = Logger.CreateLogSource("SBGVR Redirect");

	private static readonly string[] RuntimePlugins = new string[4] { "openvr_api.dll", "openxr_loader.dll", "UnityOpenXR.dll", "XRSDKOpenVR.dll" };

	private static string _dataPath = "";

	private static string _sourceData = "";

	private static string _sourcePlugins = "";

	private static readonly HashSet<string> PluginNames = new HashSet<string>(RuntimePlugins, StringComparer.OrdinalIgnoreCase);

	private static readonly HashSet<string> PluginsWithOwnLookups = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "UnityOpenXR.dll", "XRSDKOpenVR.dll" };

	private static readonly HashSet<IntPtr> PatchedModules = new HashSet<IntPtr>();

	private static readonly object Lock = new object();

	private static readonly HashSet<string> Logged = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

	private static readonly CreateFileWFn RealCreateFileW = Real<CreateFileWFn>("CreateFileW");

	private static readonly GetFileAttributesWFn RealGetFileAttributesW = Real<GetFileAttributesWFn>("GetFileAttributesW");

	private static readonly GetFileAttributesExWFn RealGetFileAttributesExW = Real<GetFileAttributesExWFn>("GetFileAttributesExW");

	private static readonly FindFirstFileWFn RealFindFirstFileW = Real<FindFirstFileWFn>("FindFirstFileW");

	private static readonly FindFirstFileExWFn RealFindFirstFileExW = Real<FindFirstFileExWFn>("FindFirstFileExW");

	private static readonly LoadLibraryExWFn RealLoadLibraryExW = Real<LoadLibraryExWFn>("LoadLibraryExW");

	private static readonly CreateFileWFn HookCreateFileW = (IntPtr n, uint a, uint s, IntPtr sec, uint d, uint f, IntPtr t) => WithPath(n, "CreateFileW", (IntPtr p) => RealCreateFileW(p, a, s, sec, d, f, t));

	private static readonly GetFileAttributesWFn HookGetFileAttributesW = (IntPtr n) => WithPath(n, "GetFileAttributesW", (IntPtr p) => RealGetFileAttributesW(p));

	private static readonly GetFileAttributesExWFn HookGetFileAttributesExW = (IntPtr n, int l, IntPtr i) => WithPath(n, "GetFileAttributesExW", (IntPtr p) => RealGetFileAttributesExW(p, l, i));

	private static readonly FindFirstFileWFn HookFindFirstFileW = (IntPtr n, IntPtr d) => WithPath(n, "FindFirstFileW", (IntPtr p) => RealFindFirstFileW(p, d));

	private static readonly FindFirstFileExWFn HookFindFirstFileExW = (IntPtr n, int l, IntPtr d, int o, IntPtr f, uint fl) => WithPath(n, "FindFirstFileExW", (IntPtr p) => RealFindFirstFileExW(p, l, d, o, f, fl));

	private static readonly LoadLibraryWFn HookLoadLibraryW = (IntPtr n) => LoadLibrary(n, 0u, "LoadLibraryW");

	private static readonly LoadLibraryExWFn HookLoadLibraryExW = (IntPtr n, IntPtr file, uint flags) => LoadLibrary(n, flags, "LoadLibraryExW");

	private static readonly Dictionary<string, Delegate> AllHooks = new Dictionary<string, Delegate>
	{
		["CreateFileW"] = HookCreateFileW,
		["GetFileAttributesW"] = HookGetFileAttributesW,
		["GetFileAttributesExW"] = HookGetFileAttributesExW,
		["FindFirstFileW"] = HookFindFirstFileW,
		["FindFirstFileExW"] = HookFindFirstFileExW,
		["LoadLibraryW"] = HookLoadLibraryW,
		["LoadLibraryExW"] = HookLoadLibraryExW
	};

	private static readonly Dictionary<string, Delegate> LibraryHooks = new Dictionary<string, Delegate>
	{
		["LoadLibraryW"] = HookLoadLibraryW,
		["LoadLibraryExW"] = HookLoadLibraryExW
	};

	public static void Install(string vrRuntimePath, string dataPath)
	{
		_dataPath = Path.GetFullPath(dataPath).TrimEnd('\\', '/');
		_sourceData = Path.Combine(vrRuntimePath, "Data");
		_sourcePlugins = Path.Combine(Path.Combine(vrRuntimePath, "Plugins"), (IntPtr.Size == 8) ? "x64" : "x86");
		Log.LogInfo((object)("Game data folder: " + _dataPath));
		Log.LogInfo((object)("VR runtime files are read from: " + vrRuntimePath));
		ReportGameFolderCopies();
		IntPtr moduleHandleW = GetModuleHandleW("UnityPlayer.dll");
		if (moduleHandleW == IntPtr.Zero)
		{
			Log.LogInfo((object)"[FAILED] UnityPlayer.dll isn't loaded; nothing redirected.");
			return;
		}
		int num = PatchImports(moduleHandleW, "UnityPlayer.dll", AllHooks);
		IntPtr intPtr = FindMono();
		if (intPtr != IntPtr.Zero)
		{
			num += PatchImports(intPtr, "Mono", LibraryHooks);
		}
		string[] array = new string[4] { "openxr_loader.dll", "openvr_api.dll", "UnityOpenXR.dll", "XRSDKOpenVR.dll" };
		foreach (string text in array)
		{
			string text2 = Path.Combine(_sourcePlugins, text);
			IntPtr intPtr2 = LoadLibraryExW(text2, IntPtr.Zero, 8u);
			if (intPtr2 == IntPtr.Zero)
			{
				Log.LogError((object)$"[FAILED] Loading {text2} failed with Windows error {Marshal.GetLastWin32Error()}.");
				continue;
			}
			Log.LogInfo((object)("Loaded " + text2));
			if (PluginsWithOwnLookups.Contains(text))
			{
				num += PatchImports(intPtr2, text, AllHooks);
			}
		}
		Log.LogInfo((object)($"{num} imports redirected. Each redirected path is logged below as it's used " + $"(the first {60})."));
	}

	private static void ReportGameFolderCopies()
	{
		List<string> list = new List<string>();
		string[] array = new string[2]
		{
			Path.Combine(_dataPath, "UnitySubsystems"),
			Path.Combine(Path.Combine(_dataPath, "StreamingAssets"), "SteamVR")
		};
		foreach (string text in array)
		{
			if (Directory.Exists(text))
			{
				list.Add(text);
			}
		}
		string path = Path.Combine(_dataPath, "Plugins");
		if (Directory.Exists(path))
		{
			string[] files = Directory.GetFiles(path, "*.dll", SearchOption.AllDirectories);
			foreach (string text2 in files)
			{
				if (PluginNames.Contains(Path.GetFileName(text2)))
				{
					list.Add(text2);
				}
			}
		}
		if (list.Count == 0)
		{
			Log.LogInfo((object)"The game folder has no copies of the VR runtime: everything VR loads comes from the mod's folder.");
		}
		else
		{
			Log.LogInfo((object)("WARNING: the game folder still has VR runtime files copied by SBGVR 1.3.2 or earlier. They aren't used (the mod's own copies are) and can be deleted:\n  " + string.Join("\n  ", list.ToArray())));
		}
	}

	internal static string? Redirect(string path)
	{
		if (string.IsNullOrEmpty(path))
		{
			return null;
		}
		string text = "";
		string text2 = path.Replace('/', '\\');
		if (text2.StartsWith("\\\\?\\", StringComparison.Ordinal))
		{
			text = "\\\\?\\";
			text2 = text2.Substring(4);
		}
		if (text2.Length < _dataPath.Length || !text2.StartsWith(_dataPath, StringComparison.OrdinalIgnoreCase))
		{
			return SteamVrFolderElsewhere(text2, text);
		}
		string text3 = text2.Substring(_dataPath.Length);
		if (text3.Length > 0 && text3[0] != '\\')
		{
			return SteamVrFolderElsewhere(text2, text);
		}
		string text4 = null;
		if (Under(text3, "\\UnitySubsystems") || Under(text3, "\\StreamingAssets\\SteamVR"))
		{
			text4 = _sourceData + text3;
		}
		else if (Under(text3, "\\Plugins"))
		{
			string text5 = text3.Substring(text3.LastIndexOf('\\') + 1);
			if (!text5.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
			{
				text5 += ".dll";
			}
			if (PluginNames.Contains(text5))
			{
				text4 = _sourcePlugins + "\\" + text5;
			}
		}
		return (text4 == null) ? null : (text + text4);
	}

	internal static string? RedirectLibrary(string path)
	{
		string text = Redirect(path);
		if (text != null || string.IsNullOrEmpty(path) || Path.IsPathRooted(path))
		{
			return text;
		}
		string text2 = path.Replace('/', '\\');
		text2 = text2.Substring(text2.LastIndexOf('\\') + 1);
		if (!text2.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
		{
			text2 += ".dll";
		}
		return PluginNames.Contains(text2) ? (_sourcePlugins + "\\" + text2) : null;
	}

	private static string? SteamVrFolderElsewhere(string p, string prefix)
	{
		int num = p.IndexOf("StreamingAssets\\SteamVR", StringComparison.OrdinalIgnoreCase);
		if (num < 0 || (num > 0 && p[num - 1] != '\\'))
		{
			return null;
		}
		int num2 = num + "StreamingAssets\\SteamVR".Length;
		if (num2 < p.Length && p[num2] != '\\')
		{
			return null;
		}
		if (p.StartsWith(_sourceData + "\\", StringComparison.OrdinalIgnoreCase))
		{
			return null;
		}
		return prefix + _sourceData + "\\" + p.Substring(num);
	}

	private static bool Under(string rest, string folder)
	{
		return rest.Equals(folder, StringComparison.OrdinalIgnoreCase) || rest.StartsWith(folder + "\\", StringComparison.OrdinalIgnoreCase);
	}

	private static T WithPath<T>(IntPtr name, string function, Func<IntPtr, T> call)
	{
		IntPtr intPtr = IntPtr.Zero;
		try
		{
			string text = ((name == IntPtr.Zero) ? null : Redirect(Marshal.PtrToStringUni(name)));
			if (text != null)
			{
				intPtr = Marshal.StringToHGlobalUni(text);
				LogRedirect(function, Marshal.PtrToStringUni(name), text);
			}
		}
		catch
		{
		}
		try
		{
			T result = call((intPtr != IntPtr.Zero) ? intPtr : name);
			SetLastError(Marshal.GetLastWin32Error());
			return result;
		}
		finally
		{
			if (intPtr != IntPtr.Zero)
			{
				int lastWin32Error = Marshal.GetLastWin32Error();
				Marshal.FreeHGlobal(intPtr);
				SetLastError(lastWin32Error);
			}
		}
	}

	private static IntPtr LoadLibrary(IntPtr name, uint flags, string function)
	{
		string text = null;
		try
		{
			if (name != IntPtr.Zero)
			{
				text = RedirectLibrary(Marshal.PtrToStringUni(name));
			}
		}
		catch
		{
			text = null;
		}
		if (text == null)
		{
			IntPtr result = RealLoadLibraryExW(name, IntPtr.Zero, flags);
			SetLastError(Marshal.GetLastWin32Error());
			return result;
		}
		LogRedirect(function, Marshal.PtrToStringUni(name), text);
		if ((flags & 0x1F00) == 0)
		{
			flags |= 8;
		}
		IntPtr intPtr = Marshal.StringToHGlobalUni(text);
		IntPtr intPtr2;
		int lastWin32Error;
		try
		{
			intPtr2 = RealLoadLibraryExW(intPtr, IntPtr.Zero, flags);
			lastWin32Error = Marshal.GetLastWin32Error();
		}
		finally
		{
			Marshal.FreeHGlobal(intPtr);
		}
		if (intPtr2 != IntPtr.Zero && PluginsWithOwnLookups.Contains(Path.GetFileName(text)))
		{
			try
			{
				PatchImports(intPtr2, Path.GetFileName(text), AllHooks);
			}
			catch (Exception ex)
			{
				Log.LogInfo((object)("Couldn't redirect " + Path.GetFileName(text) + "'s own file lookups: " + ex.Message));
			}
		}
		if (intPtr2 == IntPtr.Zero)
		{
			Log.LogInfo((object)$"[FAILED] Loading {text} failed with Windows error {lastWin32Error}.");
		}
		SetLastError(lastWin32Error);
		return intPtr2;
	}

	private static void LogRedirect(string function, string from, string to)
	{
		lock (Lock)
		{
			if (Logged.Count < 60 && Logged.Add(function + "|" + from))
			{
				Log.LogInfo((object)(function + ": " + from + " -> " + to));
			}
		}
	}

	private static int PatchImports(IntPtr module, string moduleName, Dictionary<string, Delegate> hooks)
	{
		lock (Lock)
		{
			if (!PatchedModules.Add(module))
			{
				return 0;
			}
		}
		IntPtr ptr = Add(module, Marshal.ReadInt32(module, 60));
		if (Marshal.ReadInt32(ptr) != 17744 || Marshal.ReadInt16(ptr, 24) != 523)
		{
			throw new BadImageFormatException(moduleName + " isn't a 64-bit Windows module");
		}
		int num = Marshal.ReadInt32(ptr, 144);
		if (num == 0)
		{
			return 0;
		}
		List<string> list = new List<string>();
		IntPtr intPtr = Add(module, num);
		while (true)
		{
			int num2 = Marshal.ReadInt32(intPtr, 0);
			int num3 = Marshal.ReadInt32(intPtr, 12);
			int num4 = Marshal.ReadInt32(intPtr, 16);
			if (num3 == 0 && num4 == 0)
			{
				break;
			}
			string a = Marshal.PtrToStringAnsi(Add(module, num3));
			if (string.Equals(a, "KERNEL32.dll", StringComparison.OrdinalIgnoreCase))
			{
				IntPtr ptr2 = Add(module, (num2 != 0) ? num2 : num4);
				int num5 = 0;
				while (true)
				{
					long num6 = Marshal.ReadInt64(ptr2, num5 * 8);
					if (num6 == 0)
					{
						break;
					}
					if (num6 >= 0)
					{
						string text = Marshal.PtrToStringAnsi(Add(module, (int)(num6 & 0x7FFFFFFF) + 2));
						if (text != null && hooks.TryGetValue(text, out Delegate value))
						{
							IntPtr intPtr2 = Add(module, num4 + num5 * 8);
							if (VirtualProtect(intPtr2, (UIntPtr)8uL, 4u, out var oldProtect))
							{
								Marshal.WriteIntPtr(intPtr2, Marshal.GetFunctionPointerForDelegate(value));
								VirtualProtect(intPtr2, (UIntPtr)8uL, oldProtect, out var _);
								list.Add(text);
							}
						}
					}
					num5++;
				}
			}
			intPtr = Add(intPtr, 20);
		}
		Log.LogInfo((object)(moduleName + ": " + ((list.Count == 0) ? "no file imports to redirect" : string.Join(", ", list.ToArray()))));
		return list.Count;
	}

	private static IntPtr FindMono()
	{
		string[] array = new string[3] { "mono-2.0-bdwgc.dll", "mono-2.0-sgen.dll", "mono.dll" };
		foreach (string name in array)
		{
			IntPtr moduleHandleW = GetModuleHandleW(name);
			if (moduleHandleW != IntPtr.Zero)
			{
				return moduleHandleW;
			}
		}
		Log.LogInfo((object)"Mono's module wasn't found; [DllImport] loads aren't redirected.");
		return IntPtr.Zero;
	}

	private static T Real<T>(string function) where T : Delegate
	{
		return (T)Marshal.GetDelegateForFunctionPointer(GetProcAddress(GetModuleHandleW("kernel32.dll"), function), typeof(T));
	}

	private static IntPtr Add(IntPtr pointer, int offset)
	{
		return new IntPtr(pointer.ToInt64() + offset);
	}

	[DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
	private static extern IntPtr GetModuleHandleW(string name);

	[DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Ansi)]
	private static extern IntPtr GetProcAddress(IntPtr module, string name);

	[DllImport("kernel32.dll")]
	private static extern bool VirtualProtect(IntPtr address, UIntPtr size, uint protect, out uint oldProtect);

	[DllImport("kernel32.dll")]
	private static extern void SetLastError(int error);

	[DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
	private static extern IntPtr LoadLibraryExW(string path, IntPtr file, uint flags);
}
public class Patcher
{
	public static IEnumerable<string> TargetDLLs { get; } = new string[1] { "Assembly-CSharp.dll" };

	public static void Patch(AssemblyDefinition assembly)
	{
	}

	public static void Initialize()
	{
		string location = Assembly.GetExecutingAssembly().Location;
		string fileName = Process.GetCurrentProcess().MainModule.FileName;
		string directoryName = Path.GetDirectoryName(fileName);
		string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileName);
		string dataPath = Path.Combine(directoryName, fileNameWithoutExtension + "_Data/");
		string directoryName2 = Path.GetDirectoryName(location);
		GameFolderRedirect.Install(Path.Combine(directoryName2, "VrRuntime"), dataPath);
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using Microsoft.CodeAnalysis;
using UnityEngine.Rendering;
using UnityEngine.Serialization;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: InternalsVisibleTo("Unity.XR.Management.Tests")]
[assembly: InternalsVisibleTo("Unity.XR.Management.EditorTests")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = "")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace UnityEngine.XR.Management
{
	[AttributeUsage(AttributeTargets.Class)]
	public sealed class XRConfigurationDataAttribute : Attribute
	{
		public string displayName { get; set; }

		public string buildSettingsKey { get; set; }

		private XRConfigurationDataAttribute()
		{
		}

		public XRConfigurationDataAttribute(string displayName, string buildSettingsKey)
		{
			this.displayName = displayName;
			this.buildSettingsKey = buildSettingsKey;
		}
	}
	public class XRGeneralSettings : ScriptableObject
	{
		public static string k_SettingsKey = "com.unity.xr.management.loader_settings";

		internal static XRGeneralSettings s_RuntimeSettingsInstance = null;

		[SerializeField]
		internal XRManagerSettings m_LoaderManagerInstance = null;

		[SerializeField]
		[Tooltip("Toggling this on/off will enable/disable the automatic startup of XR at run time.")]
		internal bool m_InitManagerOnStart = true;

		private XRManagerSettings m_XRManager = null;

		private bool m_ProviderIntialized = false;

		private bool m_ProviderStarted = false;

		public XRManagerSettings Manager
		{
			get
			{
				return m_LoaderManagerInstance;
			}
			set
			{
				m_LoaderManagerInstance = value;
			}
		}

		public static XRGeneralSettings Instance => s_RuntimeSettingsInstance;

		public XRManagerSettings AssignedSettings => m_LoaderManagerInstance;

		public bool InitManagerOnStart => m_InitManagerOnStart;

		private void Awake()
		{
			Debug.Log((object)"XRGeneral Settings awakening...");
			s_RuntimeSettingsInstance = this;
			Application.quitting += Quit;
			Object.DontDestroyOnLoad((Object)(object)s_RuntimeSettingsInstance);
		}

		private static void Quit()
		{
			XRGeneralSettings instance = Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				instance.DeInitXRSDK();
			}
		}

		private void Start()
		{
			StartXRSDK();
		}

		private void OnDestroy()
		{
			DeInitXRSDK();
		}

		[RuntimeInitializeOnLoadMethod(/*Could not decode attribute arguments.*/)]
		internal static void AttemptInitializeXRSDKOnLoad()
		{
			XRGeneralSettings instance = Instance;
			if (!((Object)(object)instance == (Object)null) && instance.InitManagerOnStart)
			{
				instance.InitXRSDK();
			}
		}

		[RuntimeInitializeOnLoadMethod(/*Could not decode attribute arguments.*/)]
		internal static void AttemptStartXRSDKOnBeforeSplashScreen()
		{
			XRGeneralSettings instance = Instance;
			if (!((Object)(object)instance == (Object)null) && instance.InitManagerOnStart)
			{
				instance.StartXRSDK();
			}
		}

		private void InitXRSDK()
		{
			if (!((Object)(object)Instance == (Object)null) && !((Object)(object)Instance.m_LoaderManagerInstance == (Object)null) && Instance.m_InitManagerOnStart)
			{
				m_XRManager = Instance.m_LoaderManagerInstance;
				if ((Object)(object)m_XRManager == (Object)null)
				{
					Debug.LogError((object)"Assigned GameObject for XR Management loading is invalid. No XR Providers will be automatically loaded.");
					return;
				}
				m_XRManager.automaticLoading = false;
				m_XRManager.automaticRunning = false;
				m_XRManager.InitializeLoaderSync();
				m_ProviderIntialized = true;
			}
		}

		private void StartXRSDK()
		{
			if ((Object)(object)m_XRManager != (Object)null && (Object)(object)m_XRManager.activeLoader != (Object)null)
			{
				m_XRManager.StartSubsystems();
				m_ProviderStarted = true;
			}
		}

		private void StopXRSDK()
		{
			if ((Object)(object)m_XRManager != (Object)null && (Object)(object)m_XRManager.activeLoader != (Object)null)
			{
				m_XRManager.StopSubsystems();
				m_ProviderStarted = false;
			}
		}

		private void DeInitXRSDK()
		{
			if ((Object)(object)m_XRManager != (Object)null && (Object)(object)m_XRManager.activeLoader != (Object)null)
			{
				m_XRManager.DeinitializeLoader();
				m_XRManager = null;
				m_ProviderIntialized = false;
			}
		}
	}
	public abstract class XRLoader : ScriptableObject
	{
		public virtual bool Initialize()
		{
			return true;
		}

		public virtual bool Start()
		{
			return true;
		}

		public virtual bool Stop()
		{
			return true;
		}

		public virtual bool Deinitialize()
		{
			return true;
		}

		public abstract T GetLoadedSubsystem<T>() where T : class, ISubsystem;

		public virtual List<GraphicsDeviceType> GetSupportedGraphicsDeviceTypes(bool buildingPlayer)
		{
			return new List<GraphicsDeviceType>();
		}
	}
	public abstract class XRLoaderHelper : XRLoader
	{
		protected Dictionary<Type, ISubsystem> m_SubsystemInstanceMap = new Dictionary<Type, ISubsystem>();

		public override T GetLoadedSubsystem<T>()
		{
			Type typeFromHandle = typeof(T);
			m_SubsystemInstanceMap.TryGetValue(typeFromHandle, out ISubsystem value);
			return value as T;
		}

		protected void StartSubsystem<T>() where T : class, ISubsystem
		{
			T loadedSubsystem = GetLoadedSubsystem<T>();
			if (loadedSubsystem != null)
			{
				((ISubsystem)loadedSubsystem).Start();
			}
		}

		protected void StopSubsystem<T>() where T : class, ISubsystem
		{
			T loadedSubsystem = GetLoadedSubsystem<T>();
			if (loadedSubsystem != null)
			{
				((ISubsystem)loadedSubsystem).Stop();
			}
		}

		protected void DestroySubsystem<T>() where T : class, ISubsystem
		{
			T loadedSubsystem = GetLoadedSubsystem<T>();
			if (loadedSubsystem != null)
			{
				Type typeFromHandle = typeof(T);
				if (m_SubsystemInstanceMap.ContainsKey(typeFromHandle))
				{
					m_SubsystemInstanceMap.Remove(typeFromHandle);
				}
				((ISubsystem)loadedSubsystem).Destroy();
			}
		}

		protected void CreateSubsystem<TDescriptor, TSubsystem>(List<TDescriptor> descriptors, string id) where TDescriptor : ISubsystemDescriptor where TSubsystem : ISubsystem
		{
			if (descriptors == null)
			{
				throw new ArgumentNullException("descriptors");
			}
			SubsystemManager.GetSubsystemDescriptors<TDescriptor>(descriptors);
			if (descriptors.Count <= 0)
			{
				return;
			}
			foreach (TDescriptor descriptor in descriptors)
			{
				ISubsystem val = null;
				if (string.Compare(((ISubsystemDescriptor)descriptor).id, id, ignoreCase: true) == 0)
				{
					val = ((ISubsystemDescriptor)descriptor/*cast due to .constrained prefix*/).Create();
				}
				if (val != null)
				{
					m_SubsystemInstanceMap[typeof(TSubsystem)] = val;
					break;
				}
			}
		}

		[Obsolete("This method is obsolete. Please use the geenric CreateSubsystem method.", false)]
		protected void CreateIntegratedSubsystem<TDescriptor, TSubsystem>(List<TDescriptor> descriptors, string id) where TDescriptor : IntegratedSubsystemDescriptor where TSubsystem : IntegratedSubsystem
		{
			CreateSubsystem<TDescriptor, TSubsystem>(descriptors, id);
		}

		[Obsolete("This method is obsolete. Please use the generic CreateSubsystem method.", false)]
		protected void CreateStandaloneSubsystem<TDescriptor, TSubsystem>(List<TDescriptor> descriptors, string id) where TDescriptor : SubsystemDescriptor where TSubsystem : Subsystem
		{
			CreateSubsystem<TDescriptor, TSubsystem>(descriptors, id);
		}

		public override bool Deinitialize()
		{
			m_SubsystemInstanceMap.Clear();
			return base.Deinitialize();
		}
	}
	public sealed class XRManagerSettings : ScriptableObject
	{
		[HideInInspector]
		private bool m_InitializationComplete = false;

		[HideInInspector]
		[SerializeField]
		private bool m_RequiresSettingsUpdate = false;

		[SerializeField]
		[Tooltip("Determines if the XR Manager instance is responsible for creating and destroying the appropriate loader instance.")]
		[FormerlySerializedAs("AutomaticLoading")]
		private bool m_AutomaticLoading = false;

		[SerializeField]
		[Tooltip("Determines if the XR Manager instance is responsible for starting and stopping subsystems for the active loader instance.")]
		[FormerlySerializedAs("AutomaticRunning")]
		private bool m_AutomaticRunning = false;

		[SerializeField]
		[Tooltip("List of XR Loader instances arranged in desired load order.")]
		[FormerlySerializedAs("Loaders")]
		private List<XRLoader> m_Loaders = new List<XRLoader>();

		[SerializeField]
		[HideInInspector]
		private HashSet<XRLoader> m_RegisteredLoaders = new HashSet<XRLoader>();

		public bool automaticLoading
		{
			get
			{
				return m_AutomaticLoading;
			}
			set
			{
				m_AutomaticLoading = value;
			}
		}

		public bool automaticRunning
		{
			get
			{
				return m_AutomaticRunning;
			}
			set
			{
				m_AutomaticRunning = value;
			}
		}

		[Obsolete("'XRManagerSettings.loaders' property is obsolete. Use 'XRManagerSettings.activeLoaders' instead to get a list of the current loaders.")]
		public List<XRLoader> loaders => m_Loaders;

		public IReadOnlyList<XRLoader> activeLoaders => m_Loaders;

		public bool isInitializationComplete => m_InitializationComplete;

		[HideInInspector]
		public XRLoader activeLoader { get; private set; }

		internal List<XRLoader> currentLoaders
		{
			get
			{
				return m_Loaders;
			}
			set
			{
				m_Loaders = value;
			}
		}

		internal HashSet<XRLoader> registeredLoaders => m_RegisteredLoaders;

		public T ActiveLoaderAs<T>() where T : XRLoader
		{
			return activeLoader as T;
		}

		public void InitializeLoaderSync()
		{
			if ((Object)(object)activeLoader != (Object)null)
			{
				Debug.LogWarning((object)"XR Management has already initialized an active loader in this scene. Please make sure to stop all subsystems and deinitialize the active loader before initializing a new one.");
				return;
			}
			foreach (XRLoader currentLoader in currentLoaders)
			{
				if ((Object)(object)currentLoader != (Object)null && CheckGraphicsAPICompatibility(currentLoader) && currentLoader.Initialize())
				{
					activeLoader = currentLoader;
					m_InitializationComplete = true;
					return;
				}
			}
			activeLoader = null;
		}

		public IEnumerator InitializeLoader()
		{
			if ((Object)(object)activeLoader != (Object)null)
			{
				Debug.LogWarning((object)"XR Management has already initialized an active loader in this scene. Please make sure to stop all subsystems and deinitialize the active loader before initializing a new one.");
				yield break;
			}
			foreach (XRLoader loader in currentLoaders)
			{
				if ((Object)(object)loader != (Object)null && CheckGraphicsAPICompatibility(loader) && loader.Initialize())
				{
					activeLoader = loader;
					m_InitializationComplete = true;
					yield break;
				}
				yield return null;
			}
			activeLoader = null;
		}

		public bool TryAddLoader(XRLoader loader, int index = -1)
		{
			if ((Object)(object)loader == (Object)null || currentLoaders.Contains(loader))
			{
				return false;
			}
			if (!m_RegisteredLoaders.Contains(loader))
			{
				return false;
			}
			if (index < 0 || index >= currentLoaders.Count)
			{
				currentLoaders.Add(loader);
			}
			else
			{
				currentLoaders.Insert(index, loader);
			}
			return true;
		}

		public bool TryRemoveLoader(XRLoader loader)
		{
			bool result = true;
			if (currentLoaders.Contains(loader))
			{
				result = currentLoaders.Remove(loader);
			}
			return result;
		}

		public bool TrySetLoaders(List<XRLoader> reorderedLoaders)
		{
			List<XRLoader> list = new List<XRLoader>(activeLoaders);
			currentLoaders.Clear();
			foreach (XRLoader reorderedLoader in reorderedLoaders)
			{
				if (!TryAddLoader(reorderedLoader))
				{
					currentLoaders = list;
					return false;
				}
			}
			return true;
		}

		private void Awake()
		{
			foreach (XRLoader currentLoader in currentLoaders)
			{
				if (!m_RegisteredLoaders.Contains(currentLoader))
				{
					m_RegisteredLoaders.Add(currentLoader);
				}
			}
		}

		private unsafe bool CheckGraphicsAPICompatibility(XRLoader loader)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			GraphicsDeviceType graphicsDeviceType = SystemInfo.graphicsDeviceType;
			List<GraphicsDeviceType> supportedGraphicsDeviceTypes = loader.GetSupportedGraphicsDeviceTypes(buildingPlayer: false);
			if (supportedGraphicsDeviceTypes.Count > 0 && !supportedGraphicsDeviceTypes.Contains(graphicsDeviceType))
			{
				Debug.LogWarning((object)$"The {((Object)loader).name} does not support the initialized graphics device, {((object)(*(GraphicsDeviceType*)(&graphicsDeviceType))/*cast due to .constrained prefix*/).ToString()}. Please change the preffered Graphics API in PlayerSettings. Attempting to start the next XR loader.");
				return false;
			}
			return true;
		}

		public void StartSubsystems()
		{
			if (!m_InitializationComplete)
			{
				Debug.LogWarning((object)"Call to StartSubsystems without an initialized manager.Please make sure wait for initialization to complete before calling this API.");
			}
			else if ((Object)(object)activeLoader != (Object)null)
			{
				activeLoader.Start();
			}
		}

		public void StopSubsystems()
		{
			if (!m_InitializationComplete)
			{
				Debug.LogWarning((object)"Call to StopSubsystems without an initialized manager.Please make sure wait for initialization to complete before calling this API.");
			}
			else if ((Object)(object)activeLoader != (Object)null)
			{
				activeLoader.Stop();
			}
		}

		public void DeinitializeLoader()
		{
			if (!m_InitializationComplete)
			{
				Debug.LogWarning((object)"Call to DeinitializeLoader without an initialized manager.Please make sure wait for initialization to complete before calling this API.");
				return;
			}
			StopSubsystems();
			if ((Object)(object)activeLoader != (Object)null)
			{
				activeLoader.Deinitialize();
				activeLoader = null;
			}
			m_InitializationComplete = false;
		}

		private void Start()
		{
			if (automaticLoading && automaticRunning)
			{
				StartSubsystems();
			}
		}

		private void OnDisable()
		{
			if (automaticLoading && automaticRunning)
			{
				StopSubsystems();
			}
		}

		private void OnDestroy()
		{
			if (automaticLoading)
			{
				DeinitializeLoader();
			}
		}
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Game.Rendering.Blur;
using Game.Rendering.CRT;
using Game.Rendering.FlashFrame;
using Game.Rendering.StealthFrame;
using HTraceAO.Rendering.URP.Infrastructure;
using HarmonyLib;
using SBGVR.Comfort;
using SBGVR.Controls;
using SBGVR.Diagnostics;
using SBGVR.Fades;
using SBGVR.Hud;
using SBGVR.Rendering;
using SBGVR.View;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Experimental.Rendering;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.InputSystem.LowLevel;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
using UnityEngine.SceneManagement;
using UnityEngine.TextCore;
using UnityEngine.UI;
using UnityEngine.XR;
using UnityEngine.XR.OpenXR.Features.Interactions;
using Uuvr;
using Uuvr.VrCamera;
using Uuvr.VrUi;
using Uuvr.VrUi.PatchModes;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("lmkHenlo")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) 2026 lmkHenlo")]
[assembly: AssemblyDescription("Super Battle Golf fixes for the UUVR VR mod.")]
[assembly: AssemblyFileVersion("1.4.2.0")]
[assembly: AssemblyInformationalVersion("1.4.2+3a9401c739943f22f40c41fe15431ddf533a5675")]
[assembly: AssemblyProduct("SBGVR")]
[assembly: AssemblyTitle("SBGVR")]
[assembly: AssemblyVersion("1.4.2.0")]
namespace SBGVR
{
	internal static class EmbeddedImage
	{
		internal static Texture2D Load(string resource, string textureName)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			byte[] array;
			using (Stream stream = typeof(EmbeddedImage).Assembly.GetManifestResourceStream(resource))
			{
				if (stream == null)
				{
					throw new FileNotFoundException(resource + " is missing from SBGVR.dll");
				}
				using MemoryStream memoryStream = new MemoryStream();
				stream.CopyTo(memoryStream);
				array = memoryStream.ToArray();
			}
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, true, false)
			{
				name = textureName,
				wrapMode = (TextureWrapMode)1,
				filterMode = (FilterMode)2,
				hideFlags = (HideFlags)61
			};
			if (ImageConversion.LoadImage(val, array, true))
			{
				return val;
			}
			Object.Destroy((Object)(object)val);
			throw new InvalidDataException(resource + " couldn't be read");
		}
	}
	[BepInPlugin("com.sbgvr", "SBGVR", "1.4.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public const string Guid = "com.sbgvr";

		public const string Name = "SBGVR";

		public const string Version = "1.4.2";

		internal const string UuvrGuid = "raicuparta.uuvr-modern";

		internal static ManualLogSource Log;

		internal static Harmony Harmony;

		private void Awake()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			Settings.Bind(((BaseUnityPlugin)this).Config);
			Harmony = new Harmony("com.sbgvr");
			GameObject val = new GameObject("SBGVR");
			((Object)val).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<VrStateTracker>();
			Patch("Screen shake", typeof(ScreenShakePatches));
			Patch("Impact and flash frames, CRT effect, menu blur", typeof(ScreenEffectPatches));
			Patch("Camera transitions", typeof(CameraTransitionPatches));
			Patch("Smoke bomb frame kept off the floating screen", typeof(StealthFramePatches));
			RailgunScopeZoom.ZoomAvailable = Patch("Railgun scope zoom", typeof(RailgunScopeZoomPatches));
			Add(val, "Railgun scope view lock, HUD and floating screen", typeof(RailgunScopeZoom));
			if (Patch("Ambient occlusion for each eye", typeof(AmbientOcclusionEyePatches)))
			{
				AmbientOcclusionEyePatches.Verify();
			}
			Patch("Ambient occlusion", typeof(AmbientOcclusionPatches));
			if (Patch("Full-view fades", typeof(FullViewFadePatches)))
			{
				val.AddComponent<FullViewFade>();
			}
			if (Patch("World-space markers", typeof(MarkerPatches)))
			{
				WorldMarker.Initialize();
				MarkerOcclusion.Initialize();
				Patch("World-space markers: icons up to MarkerViewAngle", typeof(MarkerViewAnglePatches));
				Add(val, "World-space reticles", typeof(WorldReticles));
				Add(val, "Aim line", typeof(AimLine));
				Patch("World-space lock-on reticles, airhorn targets, timers and popups", typeof(MoreMarkerPatches));
			}
			Add(val, "Main menu background", typeof(MenuBackground));
			Add(val, "Controller layout in the main menu", typeof(MenuControlsPanel));
			Add(val, "Recenter key", typeof(Recenter));
			if (Settings.MotionControls.Value)
			{
				EnableOpenXrControllers();
				Add(val, "Motion controls", typeof(MotionControls));
				Patch("Meta Quest button prompts: on device switch", typeof(MetaButtonPromptPatches));
				Add(val, "Meta Quest button prompts", typeof(MetaButtonPrompts));
				if (Settings.MotionCamera.Value)
				{
					Add(val, "Motion camera", typeof(MotionCamera));
					Add(val, "Motion camera for weapons", typeof(WeaponMotionCamera));
				}
			}
			if (Patch("Aiming with the controller or head", typeof(ControllerAimPatches)) && Patch("Aiming with the controller or head: rocket launcher lock-on", typeof(ControllerAimLockOnPatches)))
			{
				Patch("Aiming with the controller or head: rocket launcher lock-on (scope)", typeof(ControllerAimLockOnPatches.RocketLauncherScope));
			}
			if (Patch("First person", typeof(FirstPersonPatches)))
			{
				Patch("First person: walking and aiming where you look", typeof(FirstPersonMovementPatches));
				Add(val, "First person toggle", typeof(FirstPersonView));
			}
			if (Settings.DiagnosticsEnabled.Value)
			{
				Add(val, "Diagnostics", typeof(VrDiagnostics));
			}
			Log.LogInfo((object)(Settings.DiagnosticsEnabled.Value ? "SBGVR 1.4.2 loaded. Diagnostics are on: VR, camera and renderer details go to this log." : "SBGVR 1.4.2 loaded."));
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void EnableOpenXrControllers()
		{
			try
			{
				string[] value = ControllerProfiles.Enable();
				Log.LogInfo((object)("[ok] OpenXR controller profiles: " + string.Join(", ", value)));
			}
			catch (Exception ex)
			{
				Log.LogError((object)("[FAILED] OpenXR controller profiles: " + ex.GetBaseException().Message + ". Controllers won't work with OpenXR; OpenVR and the rest of SBGVR work as before."));
			}
		}

		private static bool Patch(string feature, Type patchClass)
		{
			try
			{
				Harmony.CreateClassProcessor(patchClass).Patch();
				Log.LogInfo((object)("[ok] " + feature));
				return true;
			}
			catch (Exception ex)
			{
				Log.LogError((object)("[FAILED] " + feature + ": " + ex.GetBaseException().Message + ". This feature is off; the rest of SBGVR works as before."));
				try
				{
					UnpatchClass(patchClass);
				}
				catch (Exception ex2)
				{
					Log.LogWarning((object)("Couldn't fully remove the patches for " + feature + ": " + ex2.Message));
				}
				return false;
			}
		}

		private static void UnpatchClass(Type patchClass)
		{
			foreach (MethodBase patchedMethod in Harmony.GetPatchedMethods())
			{
				Patches patchInfo = Harmony.GetPatchInfo(patchedMethod);
				foreach (Patch prefix in patchInfo.Prefixes)
				{
					Remove(patchedMethod, prefix);
				}
				foreach (Patch postfix in patchInfo.Postfixes)
				{
					Remove(patchedMethod, postfix);
				}
				foreach (Patch transpiler in patchInfo.Transpilers)
				{
					Remove(patchedMethod, transpiler);
				}
			}
			void Remove(MethodBase original, Patch patch)
			{
				if (patch.owner == "com.sbgvr" && patch.PatchMethod.DeclaringType == patchClass)
				{
					Harmony.Unpatch(original, patch.PatchMethod);
				}
			}
		}

		private static void Add(GameObject host, string feature, Type component)
		{
			try
			{
				host.AddComponent(component);
				Log.LogInfo((object)("[ok] " + feature));
			}
			catch (Exception ex)
			{
				Log.LogError((object)("[FAILED] " + feature + ": " + ex.GetBaseException().Message));
			}
		}
	}
	internal enum CameraTransitionMode
	{
		Game,
		Fast,
		Instant
	}
	internal enum MenuBackgroundMode
	{
		Moving,
		Still
	}
	internal static class Settings
	{
		internal static ConfigEntry<float> ScreenShake;

		internal static ConfigEntry<bool> ImpactFrames;

		internal static ConfigEntry<bool> FlashFrames;

		internal static ConfigEntry<CameraTransitionMode> CameraTransitions;

		internal static ConfigEntry<MenuBackgroundMode> MenuBackground;

		internal static ConfigEntry<bool> FullViewFades;

		internal static ConfigEntry<Key> RecenterKey;

		internal static ConfigEntry<bool> WorldSpaceMarkers;

		internal static ConfigEntry<bool> MarkersOnTop;

		internal static ConfigEntry<float> MarkerScale;

		internal static ConfigEntry<float> MarkerViewAngle;

		internal static ConfigEntry<bool> PlayersCoverMarkers;

		internal static ConfigEntry<bool> WorldSpaceReticles;

		internal static ConfigEntry<bool> AimLine;

		internal static ConfigEntry<bool> MenuControls;

		internal static ConfigEntry<MenuControlsSide> MenuControlsSide;

		internal static ConfigEntry<bool> AmbientOcclusion;

		internal static ConfigEntry<bool> MotionControls;

		internal static ConfigEntry<bool> ControllerAiming;

		internal static ConfigEntry<ControllerHand> DominantHand;

		internal static ConfigEntry<float> ControllerAimPitch;

		internal static ConfigEntry<bool> MirrorButtons;

		internal static ConfigEntry<bool> MotionCamera;

		internal static ConfigEntry<float> MotionCameraStrength;

		internal static ConfigEntry<float> MotionCameraMovement;

		internal static ConfigEntry<float> MotionCameraMaxYaw;

		internal static ConfigEntry<float> MotionCameraMaxPitch;

		internal static ConfigEntry<bool> FirstPerson;

		internal static ConfigEntry<Key> FirstPersonKey;

		internal static ConfigEntry<bool> FirstPersonControllerToggle;

		internal static ConfigEntry<TurnMode> FirstPersonTurn;

		internal static ConfigEntry<float> SnapTurnAngle;

		internal static ConfigEntry<float> FirstPersonEyeOffset;

		internal static ConfigEntry<bool> DiagnosticsEnabled;

		internal static ConfigEntry<float> PerformanceLogInterval;

		internal static void Bind(ConfigFile config)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Expected O, but got Unknown
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Expected O, but got Unknown
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Expected O, but got Unknown
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Expected O, but got Unknown
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Expected O, but got Unknown
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Expected O, but got Unknown
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bd: Expected O, but got Unknown
			//IL_0458: Unknown result type (might be due to invalid IL or missing references)
			//IL_0462: Expected O, but got Unknown
			//IL_0490: Unknown result type (might be due to invalid IL or missing references)
			//IL_049a: Expected O, but got Unknown
			//IL_04e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ed: Expected O, but got Unknown
			ScreenShake = config.Bind<float>("VR Comfort", "ScreenShake", 0.25f, new ConfigDescription("Camera shake in VR, as a share of the shake the game would use with your Screen shake setting. 0 = no shake, 1 = the game's shake.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			ImpactFrames = config.Bind<bool>("VR Comfort", "ImpactFrames", false, "Show the game's impact frames (the brief distorted, recoloured frame when an explosion goes off near you) in VR. They fill your whole view and are centred for a flat screen.");
			FlashFrames = config.Bind<bool>("VR Comfort", "FlashFrames", true, "Show the game's flash frames in VR: the full-view flash with a doubled picture that blinds you when another player's flash camera catches you. Off = you aren't blinded in VR.");
			CameraTransitions = config.Bind<CameraTransitionMode>("VR Comfort", "CameraTransitions", CameraTransitionMode.Game, "How the camera moves when the game switches views, for example to the hole overview and back. Game = the game's own sweep, Fast = the same sweep in about a third of the time, Instant = a cut.");
			MenuBackground = config.Bind<MenuBackgroundMode>("VR Comfort", "MenuBackground", MenuBackgroundMode.Still, "The main menu's background scenes. Moving = the game's slow camera pans, Still = each scene holds still. The game still fades between scenes either way.");
			FullViewFades = config.Bind<bool>("VR Comfort", "FullViewFades", true, "Fade your whole view when the game fades the screen (scene changes, the main menu's background), instead of only the floating screen.");
			RecenterKey = config.Bind<Key>("VR Comfort", "RecenterKey", (Key)97, "Key that turns the view so the direction you're facing becomes straight ahead. None = no key.");
			WorldSpaceMarkers = config.Bind<bool>("VR HUD", "WorldSpaceMarkers", true, "Draw markers (ball, hole and other icons, name tags, the target reticle) in the world at their target, so each eye sees them at the right depth. Off = UUVR's floating screen, where markers on nearby targets look doubled.");
			MarkersOnTop = config.Bind<bool>("VR HUD", "MarkersOnTop", true, "Draw world-space markers over scenery, like the game does. Menus on the floating screen still cover them. Off = scenery in front of a target hides its marker. Weapon reticles are always drawn on top.");
			MarkerScale = config.Bind<float>("VR HUD", "MarkerScale", 1f, new ConfigDescription("Size of world-space markers. 1 = the size they have on UUVR's floating screen.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 4f), Array.Empty<object>()));
			MarkerViewAngle = config.Bind<float>("VR HUD", "MarkerViewAngle", 70f, new ConfigDescription("Icons for targets within this many degrees of straight ahead are drawn in the world; targets further round get the game's arrow at the edge of the floating screen.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(30f, 120f), Array.Empty<object>()));
			WorldSpaceReticles = config.Bind<bool>("VR HUD", "WorldSpaceReticles", true, "Draw weapon reticles in the world at the point you're aiming at, so both eyes see them on the target, always on top of scenery and characters. Off = on UUVR's floating screen, where they look doubled against a distant target.");
			AimLine = config.Bind<bool>("VR HUD", "AimLine", false, "With WorldSpaceReticles, draw a thin white line from your character's hand to the weapon reticle while you aim, so you can see where the shot goes from where it leaves. Not for the railgun, thunderstorm or flash camera.");
			MenuControls = config.Bind<bool>("VR HUD", "MenuControls", true, "With MotionControls, show the VR controller layout on a panel next to the floating screen while you're in the main menu (from the moment the game starts) and while the pause menu is open. It never covers the menu: look down (or to the side, see MenuControlsSide) to read it.");
			MenuControlsSide = config.Bind<MenuControlsSide>("VR HUD", "MenuControlsSide", SBGVR.Hud.MenuControlsSide.Below, "Where the menus' controller layout is: Below the floating screen, tilted towards you, or to its Left or Right.");
			PlayersCoverMarkers = config.Bind<bool>("VR HUD", "PlayersCoverMarkers", false, "With MarkersOnTop, a player character (yours or anyone else's) in front of a marker covers it, while scenery still doesn't. A name tag or teammate icon isn't covered by the player it belongs to, and weapon reticles aren't covered at all.");
			AmbientOcclusion = config.Bind<bool>("VR Graphics", "AmbientOcclusion", true, "The game's ambient occlusion (soft shading where surfaces meet) in VR. It costs more than on a flat screen: each eye is drawn separately, at the headset's resolution. Off = none in VR; the game's own setting still applies on a flat screen.");
			MotionControls = config.Bind<bool>("VR Controls", "MotionControls", true, "Play with your VR controllers: while VR runs, their thumbsticks, trigger buttons and buttons work like a gamepad, including your gamepad rebinds. Left thumbstick moves, right thumbstick turns the camera, left trigger button aims, right trigger button swings, A jumps, B dives, X interacts, Y changes the swing angle, the right grip button and a tap of the left grip button cycle items, and the Menu button pauses (through SteamVR it opens SteamVR's menu instead). Hold the left grip button for more: right thumbstick = D-pad (emotes, push to talk, votes), A = pause, B = scoreboard. A real gamepad, keyboard and mouse still work. Restart the game after changing this.");
			ControllerAiming = config.Bind<bool>("VR Controls", "ControllerAiming", true, "With MotionControls, weapons aim where your DominantHand controller points while you aim or use them (dueling pistol, elephant gun, rocket launcher and its lock-on, railgun, freeze bomb, thunderstorm), and your character turns to face that way when you use them. Golf swings still follow the camera. Only while you're playing with the controllers: after you use a gamepad, keyboard or mouse, weapons aim along the camera (or your head, in first person) until you use a controller again. Off = weapons always aim along the camera (or your head, in first person).");
			DominantHand = config.Bind<ControllerHand>("VR Controls", "DominantHand", ControllerHand.Right, "The controller weapons aim with: Right or Left. Buttons stay where they are; see MirrorButtons.");
			ControllerAimPitch = config.Bind<float>("VR Controls", "ControllerAimPitch", 0f, new ConfigDescription("Degrees to tilt the aim from where the controller points: positive tilts it down, negative up. For controllers that aim too high or low in your hand.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-45f, 45f), Array.Empty<object>()));
			MirrorButtons = config.Bind<bool>("VR Controls", "MirrorButtons", false, "With MotionControls, mirror the button layout left to right, for example for left-handed play with DominantHand = Left: the right controller moves and aims items, the left one turns the camera and swings or fires, X and Y act as A and B, and the right grip button opens the D-pad layer. The Menu button stays on the left controller.");
			MotionCamera = config.Bind<bool>("VR Controls", "MotionCamera", true, "With MotionControls, small movements of your DominantHand controller turn the camera, only while you're playing with the controllers (not a gamepad, keyboard or mouse). Swings: while you aim and charge a golf club or rocket club swing, turn the controller or move it sideways to turn the camera left or right, like the right thumbstick (and, with MotionCameraMaxPitch above 0, tilt it to look up or down). Your character faces the camera while aiming, so this fine-tunes where the swing goes. It starts from how you hold the controller when you start aiming and stops when you swing; the thumbstick still works. In first person it turns left and right only. The MotionCamera settings below tune swings only. Items (with ControllerAiming): while you aim an item, in third or first person, turning or tilting the controller turns the camera by the same angle (1:1), and weapons aim along the camera. The aim starts where the controller points and goes back there after each shot; when you stop aiming, the camera's tilt eases back to where it was.");
			MotionCameraStrength = config.Bind<float>("VR Controls", "MotionCameraStrength", 0.25f, new ConfigDescription("How much of the controller's turn and tilt goes into the camera: 0.25 = turning it 8 degrees turns the camera about 2 degrees.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 1f), Array.Empty<object>()));
			MotionCameraMovement = config.Bind<float>("VR Controls", "MotionCameraMovement", 2f, new ConfigDescription("Degrees the camera turns for every 10 cm you move the controller sideways. 0 = only turning and tilting count.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
			MotionCameraMaxYaw = config.Bind<float>("VR Controls", "MotionCameraMaxYaw", 30f, new ConfigDescription("The furthest the controller turns the camera left or right while aiming, in degrees.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 45f), Array.Empty<object>()));
			MotionCameraMaxPitch = config.Bind<float>("VR Controls", "MotionCameraMaxPitch", 0f, new ConfigDescription("The furthest the controller tilts the camera up or down while aiming, in degrees. 0 = left and right only.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 30f), Array.Empty<object>()));
			FirstPerson = config.Bind<bool>("VR First Person", "FirstPerson", false, "See through your character's eyes in VR instead of from the third-person camera behind them. FirstPersonKey and the controller toggle switch this, and it's remembered. You look around and up and down with your head, and walking goes where you look. The game switches back to the third-person camera on its own while you're knocked out, respawning or spectating, and returns to first person afterwards. VR only: a flat screen always uses the third-person camera.");
			FirstPersonKey = config.Bind<Key>("VR First Person", "FirstPersonKey", (Key)98, "Key that switches between first person and third person in VR. None = no key.");
			FirstPersonControllerToggle = config.Bind<bool>("VR First Person", "FirstPersonControllerToggle", true, "With MotionControls, hold the left grip button and press the right thumbstick to switch between first person and third person (the right grip button and left thumbstick with MirrorButtons). Pressing the thumbstick without the grip button still drops your item.");
			FirstPersonTurn = config.Bind<TurnMode>("VR First Person", "FirstPersonTurn", TurnMode.Smooth, "How the right thumbstick turns you in first person. Snap = turns in steps of SnapTurnAngle, Smooth = turns continuously, like the third-person camera. A mouse always turns smoothly.");
			SnapTurnAngle = config.Bind<float>("VR First Person", "SnapTurnAngle", 30f, new ConfigDescription("Degrees each snap turn turns you, with FirstPersonTurn = Snap.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(15f, 90f), Array.Empty<object>()));
			FirstPersonEyeOffset = config.Bind<float>("VR First Person", "FirstPersonEyeOffset", 0f, new ConfigDescription("Raises (positive) or lowers (negative) your eyes in first person, in metres.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-0.5f, 0.5f), Array.Empty<object>()));
			DiagnosticsEnabled = config.Bind<bool>("Diagnostics", "Enabled", true, "Write VR, camera and renderer details to the BepInEx log (LogOutput.log), so problems in the headset can be tracked down from the log. Only changes are logged, not every frame.");
			PerformanceLogInterval = config.Bind<float>("Diagnostics", "PerformanceLogInterval", 30f, new ConfigDescription("Seconds between frame rate lines in the log while VR is running. 0 = never.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 600f), Array.Empty<object>()));
		}
	}
	internal static class VrState
	{
		private static readonly List<XRDisplaySubsystem> Displays = new List<XRDisplaySubsystem>();

		internal static bool IsRunning { get; private set; }

		internal static event Action<bool> Changed;

		internal static Camera ViewCamera()
		{
			VrCamera highestDepthVrCamera = VrCamera.HighestDepthVrCamera;
			if ((Object)(object)highestDepthVrCamera != (Object)null && ((Behaviour)highestDepthVrCamera).isActiveAndEnabled && (Object)(object)highestDepthVrCamera.ParentCamera != (Object)null)
			{
				return highestDepthVrCamera.ParentCamera;
			}
			return Camera.main;
		}

		internal static void Refresh()
		{
			SubsystemManager.GetSubsystems<XRDisplaySubsystem>(Displays);
			bool flag = false;
			foreach (XRDisplaySubsystem display in Displays)
			{
				if (((IntegratedSubsystem)display).running)
				{
					flag = true;
					break;
				}
			}
			if (flag == IsRunning)
			{
				return;
			}
			IsRunning = flag;
			Plugin.Log.LogInfo((object)(flag ? "VR started: VR settings are on." : "VR stopped: the game is back to normal."));
			Action<bool> changed = VrState.Changed;
			if (changed == null)
			{
				return;
			}
			Delegate[] invocationList = changed.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action<bool> action = (Action<bool>)invocationList[i];
				try
				{
					action(flag);
				}
				catch (Exception arg)
				{
					Plugin.Log.LogError((object)("VR " + (flag ? "start" : "stop") + ": " + (action.Method.DeclaringType?.Name ?? "a feature") + " " + $"failed; the other features carry on. {arg}"));
				}
			}
		}
	}
	[DefaultExecutionOrder(-30000)]
	internal sealed class VrStateTracker : MonoBehaviour
	{
		private void Update()
		{
			VrState.Refresh();
		}
	}
}
namespace SBGVR.View
{
	[HarmonyPatch]
	internal static class FirstPersonPatches
	{
		[HarmonyPatch(typeof(CameraModuleController), "TransitionToInternal")]
		[HarmonyPrefix]
		private static void KeepFirstPerson(ref CameraModuleType cameraType)
		{
			if ((int)cameraType == 1 && FirstPersonView.ShouldRedirectToFirstPerson())
			{
				cameraType = (CameraModuleType)2;
			}
		}

		[HarmonyPatch(typeof(FirstPersonCameraModule), "UpdateModule")]
		[HarmonyPrefix]
		private static void BeforeUpdateModule(FirstPersonCameraModule __instance)
		{
			FirstPersonView.BeforeModuleUpdate(__instance);
		}

		[HarmonyPatch(typeof(FirstPersonCameraModule), "Rotate")]
		[HarmonyPrefix]
		private static bool Turn(FirstPersonCameraModule __instance, ref Vector2 axis)
		{
			//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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (!FirstPersonView.Shows(__instance))
			{
				return true;
			}
			if (FirstPersonView.InGolfCart())
			{
				__instance.InformNoRotation();
				return false;
			}
			axis.y = 0f;
			if (Settings.FirstPersonTurn.Value != TurnMode.Snap || !PlayerInput.UsingGamepad || FirstPersonView.IsAimingShot())
			{
				return true;
			}
			CameraActions camera = PlayerInput.Controls.Camera;
			Vector2 val = ((CameraActions)(ref camera)).Look.ReadValue<Vector2>();
			FirstPersonView.SnapTurn(__instance, val.x);
			__instance.InformNoRotation();
			return false;
		}

		[HarmonyPatch(typeof(PlayerInventory), "UpdateIsInFirstPersonAim")]
		[HarmonyPrefix]
		private static void BeforeRailgunScope(out float __state)
		{
			__state = float.NaN;
			FirstPersonCameraModule val = default(FirstPersonCameraModule);
			if (FirstPersonView.Owns && CameraModuleController.TryGetFirstPersonModule(ref val) && (Object)(object)val != (Object)null)
			{
				__state = val.Yaw;
			}
		}

		[HarmonyPatch(typeof(PlayerInventory), "UpdateIsInFirstPersonAim")]
		[HarmonyPostfix]
		private static void AfterRailgunScope(PlayerInventory __instance, float __state)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			FirstPersonCameraModule val = default(FirstPersonCameraModule);
			if (!float.IsNaN(__state) && FirstPersonView.Owns && CameraModuleController.TryGetFirstPersonModule(ref val) && !((Object)(object)val == (Object)null))
			{
				val.SetYaw(__state);
				val.SetPitch(0f);
				val.SetLocalPosition(Vector3.zero);
				if (!__instance.IsInFirstPersonAim)
				{
					val.CancelFovOverrideInstantly();
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class FirstPersonMovementPatches
	{
		private static readonly MethodInfo GetYaw = AccessTools.PropertyGetter(typeof(FirstPersonCameraModule), "Yaw");

		private static readonly MethodInfo YawOf = AccessTools.Method(typeof(FirstPersonView), "YawOf", (Type[])null, (Type[])null);

		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return Method("ProcessMovementInput");
			yield return Method("UpdateTargetYaw");
		}

		private static MethodBase Method(string name)
		{
			return AccessTools.Method(typeof(PlayerMovement), name, (Type[])null, (Type[])null) ?? throw new MissingMethodException("PlayerMovement", name);
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, MethodBase original)
		{
			List<CodeInstruction> list = instructions.ToList();
			int num = 0;
			foreach (CodeInstruction item in list)
			{
				if (CodeInstructionExtensions.Calls(item, GetYaw))
				{
					item.opcode = OpCodes.Call;
					item.operand = YawOf;
					num++;
				}
			}
			if (num == 0)
			{
				throw new InvalidOperationException("PlayerMovement." + original.Name + " no longer reads the first-person camera's yaw.");
			}
			return list;
		}
	}
	internal enum TurnMode
	{
		Snap,
		Smooth
	}
	internal sealed class FirstPersonView : MonoBehaviour
	{
		private const float EyeHeightSmoothing = 0.2f;

		private const float EyeHeight = 1.5f;

		private const float SnapThreshold = 0.7f;

		private const float SnapReset = 0.3f;

		private static Transform _anchor;

		private static FirstPersonCameraModule _anchoredModule;

		private static bool _owns;

		private static float _eyeHeight;

		private static bool _snapArmed = true;

		private static string _lastStatus;

		private static bool _loggedEyeHeight;

		private static bool _wasAimingShot;

		internal static bool Owns => _owns;

		internal static bool Shows(FirstPersonCameraModule module)
		{
			if (_owns && (Object)(object)module != (Object)null)
			{
				return module == _anchoredModule;
			}
			return false;
		}

		internal static void Toggle()
		{
			if (VrState.IsRunning)
			{
				Settings.FirstPerson.Value = !Settings.FirstPerson.Value;
				Plugin.Log.LogInfo((object)(Settings.FirstPerson.Value ? "First person: on." : "First person: off."));
			}
		}

		private void OnEnable()
		{
			VrState.Changed += OnVrChanged;
		}

		private void OnDisable()
		{
			VrState.Changed -= OnVrChanged;
		}

		private static void OnVrChanged(bool running)
		{
			_snapArmed = true;
		}

		private void Update()
		{
			HandleKey();
			Refresh();
			StartShotAimWhereLooking();
		}

		private static void StartShotAimWhereLooking()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			bool flag = _owns && IsAimingShot();
			bool num = flag && !_wasAimingShot;
			_wasAimingShot = flag;
			if (!num)
			{
				return;
			}
			FirstPersonCameraModule anchoredModule = _anchoredModule;
			if (!Shows(anchoredModule) || !ControllerAim.TryGetHeadPose(out var _, out var rotation))
			{
				return;
			}
			float num2 = Mathf.DeltaAngle(anchoredModule.Yaw, HorizontalYaw(rotation));
			if (!(Mathf.Abs(num2) < 0.1f))
			{
				anchoredModule.SetYaw(anchoredModule.Yaw + num2);
				VrCameraOffset.RecenterRotation = Quaternion.Euler(0f, 0f - num2, 0f) * VrCameraOffset.RecenterRotation;
				if (Settings.DiagnosticsEnabled.Value)
				{
					Plugin.Log.LogInfo((object)$"First person: shot aim starts where you're looking ({num2:+0;-0;0}° from the view's forward).");
				}
			}
		}

		private static void HandleKey()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (!VrState.IsRunning)
			{
				return;
			}
			Key value = Settings.FirstPersonKey.Value;
			if ((int)value == 0)
			{
				return;
			}
			Keyboard current = Keyboard.current;
			if (current != null)
			{
				KeyControl val = current[value];
				if (val != null && ((ButtonControl)val).wasPressedThisFrame)
				{
					Toggle();
				}
			}
		}

		private static void Refresh()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Invalid comparison between Unknown and I4
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Invalid comparison between Unknown and I4
			CameraModuleType currentModuleType = CameraModuleController.CurrentModuleType;
			if (_owns && (int)currentModuleType != 2)
			{
				_owns = false;
			}
			bool value = Settings.FirstPerson.Value;
			string reason;
			bool flag = IsAllowed(out reason);
			LogStatus(value, flag, reason);
			if (value && flag)
			{
				if (!_owns && !CameraModuleController.IsTransitioning)
				{
					if ((int)currentModuleType == 1)
					{
						Enter();
					}
					else if ((int)currentModuleType == 2)
					{
						Adopt();
					}
				}
			}
			else if (_owns && !InRailgunScope())
			{
				Exit();
			}
			if (!_owns && (Object)(object)_anchoredModule != (Object)null && !CameraModuleController.IsTransitioning)
			{
				ReleaseViewer();
			}
			if (!_owns)
			{
				_snapArmed = true;
			}
		}

		private static bool IsAllowed(out string reason)
		{
			reason = null;
			if (!VrState.IsRunning)
			{
				return false;
			}
			PlayerInfo localPlayerInfo = GameManager.LocalPlayerInfo;
			PlayerMovement localPlayerMovement = GameManager.LocalPlayerMovement;
			if ((Object)(object)localPlayerInfo == (Object)null || (Object)(object)localPlayerMovement == (Object)null)
			{
				return false;
			}
			FirstPersonCameraModule val = default(FirstPersonCameraModule);
			if (!CameraModuleController.TryGetFirstPersonModule(ref val) || (Object)(object)val == (Object)null)
			{
				return false;
			}
			PlayerSpectator localPlayerAsSpectator = GameManager.LocalPlayerAsSpectator;
			if ((Object)(object)localPlayerAsSpectator != (Object)null && localPlayerAsSpectator.IsSpectating)
			{
				reason = "spectating";
				return false;
			}
			if (localPlayerMovement.IsKnockedOutOrRecovering)
			{
				reason = "knocked out";
				return false;
			}
			if (localPlayerMovement.IsRespawningOrDrowning)
			{
				reason = "respawning";
				return false;
			}
			return true;
		}

		private static void LogStatus(bool wanted, bool allowed, string reason)
		{
			string text = ((wanted && !allowed && reason != null) ? reason : null);
			if (!(text == _lastStatus))
			{
				string lastStatus = _lastStatus;
				_lastStatus = text;
				if (text != null)
				{
					Plugin.Log.LogInfo((object)("First person: third person while " + text + "."));
				}
				else if (wanted && lastStatus != null)
				{
					Plugin.Log.LogInfo((object)"First person: back in first person.");
				}
			}
		}

		private static bool InRailgunScope()
		{
			PlayerInventory localPlayerInventory = GameManager.LocalPlayerInventory;
			if ((Object)(object)localPlayerInventory != (Object)null)
			{
				return localPlayerInventory.IsInFirstPersonAim;
			}
			return false;
		}

		private static void Enter()
		{
			FirstPersonCameraModule val = default(FirstPersonCameraModule);
			if (CameraModuleController.TryGetFirstPersonModule(ref val) && !((Object)(object)val == (Object)null))
			{
				Prepare(val, fromOrbit: true);
				_owns = true;
				GameplayCameraManager.TransitionTo((CameraModuleType)2);
			}
		}

		private static void Adopt()
		{
			FirstPersonCameraModule val = default(FirstPersonCameraModule);
			if (CameraModuleController.TryGetFirstPersonModule(ref val) && !((Object)(object)val == (Object)null))
			{
				Prepare(val, fromOrbit: false);
				_owns = true;
			}
		}

		private static void Exit()
		{
			_owns = false;
			FirstPersonCameraModule val = default(FirstPersonCameraModule);
			OrbitCameraModule val2 = default(OrbitCameraModule);
			if (CameraModuleController.TryGetFirstPersonModule(ref val) && (Object)(object)val != (Object)null && CameraModuleController.TryGetOrbitModule(ref val2) && (Object)(object)val2 != (Object)null)
			{
				val2.SetYaw(val.Yaw);
				val2.ForceUpdateModule();
			}
			GameplayCameraManager.TransitionTo((CameraModuleType)1);
		}

		internal static bool ShouldRedirectToFirstPerson()
		{
			if (!Settings.FirstPerson.Value || !IsAllowed(out var _))
			{
				return false;
			}
			FirstPersonCameraModule val = default(FirstPersonCameraModule);
			if (!CameraModuleController.TryGetFirstPersonModule(ref val) || (Object)(object)val == (Object)null)
			{
				return false;
			}
			if (!_owns)
			{
				Prepare(val, fromOrbit: true);
			}
			_owns = true;
			return true;
		}

		private static void Prepare(FirstPersonCameraModule module, bool fromOrbit)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			if (fromOrbit)
			{
				OrbitCameraModule val = default(OrbitCameraModule);
				if (CameraModuleController.TryGetOrbitModule(ref val) && (Object)(object)val != (Object)null)
				{
					module.SetYaw(val.Yaw);
				}
				module.CancelFovOverrideInstantly();
			}
			module.SetPitch(0f);
			module.SetRoll(0f);
			UpdateAnchor(snap: true);
			module.SetViewer(Anchor());
			module.SetLocalPosition(Vector3.zero);
			_anchoredModule = module;
			_snapArmed = true;
		}

		private static void ReleaseViewer()
		{
			FirstPersonCameraModule anchoredModule = _anchoredModule;
			_anchoredModule = null;
			PlayerInfo localPlayerInfo = GameManager.LocalPlayerInfo;
			if ((Object)(object)anchoredModule != (Object)null && (Object)(object)localPlayerInfo != (Object)null)
			{
				anchoredModule.SetViewer(((Component)localPlayerInfo).transform);
			}
		}

		internal static void BeforeModuleUpdate(FirstPersonCameraModule module)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)module == (Object)null || module != _anchoredModule)
			{
				return;
			}
			UpdateAnchor(snap: false);
			module.SetViewer(_anchor);
			module.SetLocalPosition(Vector3.zero);
			if (_owns)
			{
				module.SetPitch(WeaponMotionCamera.FirstPersonPitch);
				module.SetRoll(0f);
				if (TryGetCart(out var cart))
				{
					module.SetYaw(HorizontalYaw(cart.rotation));
				}
			}
		}

		private static bool TryGetCart(out Transform cart)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			cart = null;
			PlayerInfo localPlayerInfo = GameManager.LocalPlayerInfo;
			if ((Object)(object)localPlayerInfo == (Object)null)
			{
				return false;
			}
			GolfCartSeat activeGolfCartSeat = localPlayerInfo.ActiveGolfCartSeat;
			if (!((GolfCartSeat)(ref activeGolfCartSeat)).IsValid() || (Object)(object)activeGolfCartSeat.golfCart == (Object)null)
			{
				return false;
			}
			GolfCartMovement movement = activeGolfCartSeat.golfCart.Movement;
			cart = (((Object)(object)movement != (Object)null) ? ((Component)movement).transform : ((Component)activeGolfCartSeat.golfCart).transform);
			return true;
		}

		internal static bool InGolfCart()
		{
			Transform cart;
			if (_owns)
			{
				return TryGetCart(out cart);
			}
			return false;
		}

		private static void UpdateAnchor(bool snap)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: 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_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			PlayerInfo localPlayerInfo = GameManager.LocalPlayerInfo;
			if (!((Object)(object)localPlayerInfo == (Object)null))
			{
				Transform transform = ((Component)localPlayerInfo).transform;
				PlayerMovement movement = localPlayerInfo.Movement;
				float num = (((Object)(object)movement != (Object)null) ? movement.CharacterScale : 1f);
				float num2 = 1.5f * num * transform.lossyScale.y + Settings.FirstPersonEyeOffset.Value;
				_eyeHeight = (snap ? num2 : Mathf.Lerp(_eyeHeight, num2, 1f - Mathf.Exp((0f - Time.unscaledDeltaTime) / 0.2f)));
				Transform cart;
				Vector3 val = (TryGetCart(out cart) ? cart.position : transform.position);
				Anchor().SetPositionAndRotation(val + Vector3.up * _eyeHeight, Quaternion.identity);
				if (snap)
				{
					LogEyeHeight(localPlayerInfo, num);
				}
			}
		}

		private static void LogEyeHeight(PlayerInfo player, float scale)
		{
			//IL_0037: 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)
			if (!_loggedEyeHeight && Settings.DiagnosticsEnabled.Value)
			{
				_loggedEyeHeight = true;
				Transform headBone = player.HeadBone;
				string text = (((Object)(object)headBone != (Object)null) ? $"{headBone.position.y - ((Component)player).transform.position.y:0.00} m" : "unknown");
				Plugin.Log.LogInfo((object)($"First person: eyes {_eyeHeight:0.00} m above the feet ({1.5f:0.00} m × scale {scale:0.##}, offset {Settings.FirstPersonEyeOffset.Value:0.00} m); " + "head bone " + text + " above the feet."));
			}
		}

		private static Transform Anchor()
		{
			//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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			if ((Object)(object)_anchor != (Object)null)
			{
				return _anchor;
			}
			GameObject val = new GameObject("SBGVR First Person Eyes")
			{
				hideFlags = (HideFlags)61
			};
			Object.DontDestroyOnLoad((Object)val);
			_anchor = val.transform;
			return _anchor;
		}

		internal static bool IsAimingShot()
		{
			PlayerGolfer localPlayerAsGolfer = GameManager.LocalPlayerAsGolfer;
			if ((Object)(object)localPlayerAsGolfer != (Object)null)
			{
				if (!localPlayerAsGolfer.IsAimingSwing && !localPlayerAsGolfer.IsChargingSwing)
				{
					return localPlayerAsGolfer.IsSwinging;
				}
				return true;
			}
			return false;
		}

		internal static float YawOf(FirstPersonCameraModule module)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (Shows(module) && !IsAimingShot() && !WeaponMotionCamera.SteersFirstPerson && ControllerAim.TryGetHeadPose(out var _, out var rotation))
			{
				return HorizontalYaw(rotation);
			}
			return module.Yaw;
		}

		internal static bool TryGetHeadAimRay(out Vector3 origin, out Vector3 direction)
		{
			//IL_0001: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			direction = default(Vector3);
			if (!Shows(_anchoredModule) || IsAimingShot() || !ControllerAim.TryGetHeadPose(out origin, out var rotation))
			{
				origin = default(Vector3);
				return false;
			}
			direction = rotation * Vector3.forward;
			return true;
		}

		private static float HorizontalYaw(Quaternion rotation)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = rotation * Vector3.forward;
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(val.x, 0f, val.z);
			if (((Vector3)(ref val2)).sqrMagnitude < 0.04f)
			{
				Vector3 val3 = rotation * Vector3.up;
				val2 = ((val.y < 0f) ? new Vector3(val3.x, 0f, val3.z) : new Vector3(0f - val3.x, 0f, 0f - val3.z));
			}
			return Mathf.Atan2(val2.x, val2.z) * 57.29578f;
		}

		internal static void SnapTurn(FirstPersonCameraModule module, float stickX)
		{
			float num = Mathf.Abs(stickX);
			if (num < 0.3f)
			{
				_snapArmed = true;
			}
			else if (_snapArmed && !(num < 0.7f))
			{
				_snapArmed = false;
				module.SetYaw(module.Yaw + Mathf.Sign(stickX) * Settings.SnapTurnAngle.Value);
			}
		}
	}
	internal sealed class RailgunScopeZoom : MonoBehaviour
	{
		private const float MaxFactor = 20f;

		private static int _factorFrame = -1;

		private static float _factor = 1f;

		private static bool _wasZoomed;

		private Transform _screen;

		private Renderer _screenRenderer;

		private Material _screenMaterial;

		private Material _onTopMaterial;

		private Vector3 _screenPosition;

		private bool _screenMoved;

		private bool _loggedLock;

		internal static bool ZoomAvailable;

		private static int _lockFrame = -1;

		private static bool _locked;

		internal static bool ViewLocked
		{
			get
			{
				if (_lockFrame == Time.frameCount)
				{
					return _locked;
				}
				_lockFrame = Time.frameCount;
				_locked = IsAimingRailgun() && CameraIsTheAim();
				return _locked;
			}
		}

		internal static float Factor
		{
			get
			{
				if (_factorFrame == Time.frameCount)
				{
					return _factor;
				}
				_factorFrame = Time.frameCount;
				_factor = ComputeFactor();
				return _factor;
			}
		}

		internal static float HudScale => 1f / Factor;

		private static float ComputeFactor()
		{
			float setting = 0f;
			float scope = 0f;
			bool flag = ZoomAvailable && ViewLocked && TryGetScopeFov(out setting, out scope);
			float result = (flag ? Mathf.Clamp(Mathf.Tan(setting * 0.5f * ((float)Math.PI / 180f)) / Mathf.Tan(scope * 0.5f * ((float)Math.PI / 180f)), 1f, 20f) : 1f);
			if (flag != _wasZoomed && flag)
			{
				LogZoom(setting);
			}
			_wasZoomed = flag;
			return result;
		}

		private static bool TryGetScopeFov(out float setting, out float scope)
		{
			setting = (scope = 0f);
			if (!VrState.IsRunning)
			{
				return false;
			}
			PlayerInventory localPlayerInventory = GameManager.LocalPlayerInventory;
			if ((Object)(object)localPlayerInventory == (Object)null || !localPlayerInventory.IsInFirstPersonAim)
			{
				return false;
			}
			FirstPersonCameraModule val = default(FirstPersonCameraModule);
			if (!CameraModuleController.TryGetFirstPersonModule(ref val) || (Object)(object)val == (Object)null)
			{
				return false;
			}
			AllSettings all = GameSettings.All;
			if (((all != null) ? all.Graphics : null) == null)
			{
				return false;
			}
			setting = all.Graphics.FieldOfView;
			scope = ((CameraModule)val).FieldOfView;
			if (setting > 1f && setting < 179f && scope > 0.1f)
			{
				return scope < 179f;
			}
			return false;
		}

		private static void LogZoom(float setting)
		{
			if (Settings.DiagnosticsEnabled.Value)
			{
				ItemSettings itemSettings = GameManager.ItemSettings;
				if (!((Object)(object)itemSettings == (Object)null))
				{
					Plugin.Log.LogInfo((object)($"[diag] Railgun scope: field of view {setting:0.#} (setting), {itemSettings.RailgunZoomInitialFov:0.#} " + $"to {itemSettings.RailgunZoomFinalFov:0.#} over {itemSettings.RailgunZoomFovChangeDuration:0.##} s (scope): " + $"magnifies {Magnification(itemSettings.RailgunZoomInitialFov):0.00}x to {Magnification(itemSettings.RailgunZoomFinalFov):0.00}x."));
				}
			}
			float Magnification(float fov)
			{
				return Mathf.Tan(setting * 0.5f * ((float)Math.PI / 180f)) / Mathf.Tan(fov * 0.5f * ((float)Math.PI / 180f));
			}
		}

		internal static bool IsAimingRailgun()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Invalid comparison between Unknown and I4
			if (!VrState.IsRunning)
			{
				return false;
			}
			PlayerInventory localPlayerInventory = GameManager.LocalPlayerInventory;
			PlayerInfo localPlayerInfo = GameManager.LocalPlayerInfo;
			if ((Object)(object)localPlayerInventory != (Object)null && (Object)(object)localPlayerInfo != (Object)null && (int)localPlayerInfo.NetworkedEquippedItem == 16)
			{
				if (!localPlayerInventory.IsInFirstPersonAim && !localPlayerInventory.IsAimingItem)
				{
					return localPlayerInventory.IsUsingItemAtAll;
				}
				return true;
			}
			return false;
		}

		private void OnEnable()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			Application.onBeforeRender += new UnityAction(UpdateViewLock);
		}

		private static bool CameraIsTheAim()
		{
			if (!Settings.MotionControls.Value || !Settings.ControllerAiming.Value || !MotionControls.InUse)
			{
				return !FirstPersonView.Owns;
			}
			Quaternion rotation;
			return WeaponMotionCamera.TryGetCameraAim(out rotation);
		}

		private void UpdateViewLock()
		{
			bool flag = (VrCamera.LookWhereGameCameraLooks = ViewLocked);
			if (flag != _loggedLock && Settings.DiagnosticsEnabled.Value)
			{
				_loggedLock = flag;
				Plugin.Log.LogInfo((object)(flag ? "Railgun: view and aim locked to the camera; the headset's rotation and position don't move them." : "Railgun: aiming ended; head tracking is back."));
			}
		}

		private void LateUpdate()
		{
			//IL_005f: 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)
			float factor = Factor;
			if (factor > 1f && FindScreen())
			{
				if (!_screenMoved)
				{
					_screenPosition = _screen.localPosition;
					_screenMoved = true;
				}
				_screen.localPosition = new Vector3(_screenPosition.x, _screenPosition.y, _screenPosition.z * factor);
				DrawScreenOnTop(onTop: true);
			}
			else
			{
				RestoreScreen();
			}
		}

		private void OnDisable()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			RestoreScreen();
			Application.onBeforeRender -= new UnityAction(UpdateViewLock);
			VrCamera.LookWhereGameCameraLooks = false;
		}

		private void RestoreScreen()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (_screenMoved)
			{
				_screenMoved = false;
				if ((Object)(object)_screen != (Object)null)
				{
					_screen.localPosition = _screenPosition;
				}
				DrawScreenOnTop(onTop: false);
			}
		}

		private bool FindScreen()
		{
			if ((Object)(object)_screen != (Object)null)
			{
				return true;
			}
			VrUiManager val = Object.FindAnyObjectByType<VrUiManager>();
			_screen = (((Object)(object)val != (Object)null) ? ((Component)val).transform.Find("VrUiContainer/VrUiQuad") : null);
			_screenRenderer = (((Object)(object)_screen != (Object)null) ? ((Component)_screen).GetComponent<Renderer>() : null);
			if ((Object)(object)_screen != (Object)null && (Object)(object)_screenRenderer != (Object)null)
			{
				return true;
			}
			_screen = null;
			return false;
		}

		private void DrawScreenOnTop(bool onTop)
		{
			//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_007b: Expected O, but got Unknown
			if ((Object)(object)_screenRenderer == (Object)null)
			{
				return;
			}
			if (onTop)
			{
				Material sharedMaterial = _screenRenderer.sharedMaterial;
				if (!((Object)(object)sharedMaterial == (Object)null) && !((Object)(object)sharedMaterial == (Object)(object)_onTopMaterial))
				{
					if ((Object)(object)_onTopMaterial != (Object)null)
					{
						Object.Destroy((Object)(object)_onTopMaterial);
					}
					_screenMaterial = sharedMaterial;
					_onTopMaterial = new Material(sharedMaterial)
					{
						name = ((Object)sharedMaterial).name + " (SBGVR scope zoom)"
					};
					_onTopMaterial.SetInt(GuiZTest.Id, 8);
					_screenRenderer.sharedMaterial = _onTopMaterial;
				}
			}
			else if ((Object)(object)_screenMaterial != (Object)null && (Object)(object)_screenRenderer.sharedMaterial == (Object)(object)_onTopMaterial)
			{
				_screenRenderer.sharedMaterial = _screenMaterial;
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)_onTopMaterial != (Object)null)
			{
				Object.Destroy((Object)(object)_onTopMaterial);
			}
		}
	}
	[HarmonyPatch]
	internal static class RailgunScopeZoomPatches
	{
		private static readonly FieldInfo Projection = AccessTools.Field(typeof(XRRenderParameter), "projection");

		private static MethodBase TargetMethod()
		{
			return AccessTools.Method(typeof(XRSystem), "BuildView", (Type[])null, (Type[])null);
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			int found = 0;
			foreach (CodeInstruction instruction in instructions)
			{
				yield return instruction;
				if (CodeInstructionExtensions.LoadsField(instruction, Projection, false))
				{
					found++;
					yield return new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(RailgunScopeZoomPatches), "Zoom", (Type[])null, (Type[])null));
				}
			}
			if (found != 1)
			{
				throw new InvalidOperationException($"XRSystem.BuildView reads the eye's projection {found} times, expected once");
			}
		}

		private static Matrix4x4 Zoom(Matrix4x4 projection)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			float factor = RailgunScopeZoom.Factor;
			if (factor <= 1f)
			{
				return projection;
			}
			projection.m00 *= factor;
			projection.m11 *= factor;
			return projection;
		}
	}
}
namespace SBGVR.Rendering
{
	[HarmonyPatch]
	internal static class AmbientOcclusionPatches
	{
		private const string OcclusionKeyword = "_SCREEN_SPACE_OCCLUSION";

		internal static bool EyePatchesApplied;

		[HarmonyPatch(typeof(HTraceAORendererFeature), "AddRenderPasses")]
		[HarmonyPrefix]
		private static bool AddRenderPasses(ref RenderingData renderingData)
		{
			if (VrState.IsRunning && (!EyePatchesApplied || !Settings.AmbientOcclusion.Value))
			{
				Shader.DisableKeyword("_SCREEN_SPACE_OCCLUSION");
				return false;
			}
			if (EyePatchesApplied)
			{
				EyeView.Capture(ref renderingData);
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal static class AmbientOcclusionEyePatches
	{
		private static readonly Dictionary<MethodInfo, MethodInfo> CameraGetters = new Dictionary<MethodInfo, MethodInfo>
		{
			[Getter("scaledPixelWidth")] = Hook("ScaledPixelWidth"),
			[Getter("scaledPixelHeight")] = Hook("ScaledPixelHeight"),
			[Getter("pixelHeight")] = Hook("PixelHeight"),
			[Getter("fieldOfView")] = Hook("FieldOfView"),
			[Getter("projectionMatrix")] = Hook("ProjectionMatrix"),
			[Getter("nonJitteredProjectionMatrix")] = Hook("NonJitteredProjectionMatrix"),
			[Getter("worldToCameraMatrix")] = Hook("WorldToCameraMatrix")
		};

		private static readonly MethodInfo GetHashCodeMethod = AccessTools.Method(typeof(object), "GetHashCode", (Type[])null, (Type[])null);

		private static readonly MethodInfo FrameCountGetter = AccessTools.PropertyGetter(typeof(Time), "frameCount");

		private static readonly MethodInfo SetGlobalVector = AccessTools.Method(typeof(CommandBuffer), "SetGlobalVector", new Type[2]
		{
			typeof(int),
			typeof(Vector4)
		}, (Type[])null);

		private const string DepthToViewParamsField = "g_HDepthToViewParamsAO";

		private static int _getterCount;

		private static int _historyKeyCount;

		private static int _depthToViewCount;

		private static MethodInfo Getter(string property)
		{
			return AccessTools.PropertyGetter(typeof(Camera), property);
		}

		private static MethodInfo Hook(string name)
		{
			return AccessTools.Method(typeof(EyeView), name, (Type[])null, (Type[])null);
		}

		private static IEnumerable<MethodBase> TargetMethods()
		{
			Assembly assembly = typeof(HTraceAORendererFeature).Assembly;
			Type[] typesFromAssembly = AccessTools.GetTypesFromAssembly(assembly);
			foreach (Type type in typesFromAssembly)
			{
				if (type.ContainsGenericParameters)
				{
					continue;
				}
				foreach (MethodBase item in type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).Cast<MethodBase>().Concat(type.GetConstructors(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)))
				{
					if (!item.IsAbstract && !item.ContainsGenericParameters && item.GetMethodBody() != null && ReadsCamera(item))
					{
						yield return item;
					}
				}
			}
		}

		private static bool ReadsCamera(MethodBase method)
		{
			try
			{
				List<KeyValuePair<OpCode, object>> list = PatchProcessor.ReadMethodBody(method).ToList();
				for (int i = 0; i < list.Count; i++)
				{
					if (list[i].Value is MethodInfo methodInfo)
					{
						if (CameraGetters.ContainsKey(methodInfo))
						{
							return true;
						}
						if (methodInfo == GetHashCodeMethod && i + 1 < list.Count && list[i + 1].Value as MethodInfo == FrameCountGetter)
						{
							return true;
						}
					}
				}
				return false;
			}
			catch (Exception)
			{
				return false;
			}
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, MethodBase original)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Expected O, but got Unknown
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Expected O, but got Unknown
			List<CodeInstruction> list = instructions.ToList();
			int num = CameraArgument(original);
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.operand is MethodInfo key && CameraGetters.TryGetValue(key, out var value) && (val.opcode == OpCodes.Callvirt || val.opcode == OpCodes.Call))
				{
					list[i] = CodeInstructionExtensions.MoveBlocksFrom(CodeInstructionExtensions.MoveLabelsFrom(new CodeInstruction(OpCodes.Call, (object)value), val), val);
					_getterCount++;
				}
				else if (val.operand is MethodInfo methodInfo && methodInfo == GetHashCodeMethod && i + 1 < list.Count && CodeInstructionExtensions.Calls(list[i + 1], FrameCountGetter) && (i == 0 || list[i - 1].opcode != OpCodes.Constrained))
				{
					list[i] = CodeInstructionExtensions.MoveBlocksFrom(CodeInstructionExtensions.MoveLabelsFrom(new CodeInstruction(OpCodes.Call, (object)Hook("HistoryKey")), val), val);
					_historyKeyCount++;
				}
				else if (num >= 0 && val.opcode == OpCodes.Ldsfld && val.operand is FieldInfo { Name: "g_HDepthToViewParamsAO" } && i + 2 < list.Count && CodeInstructionExtensions.IsLdloc(list[i + 1], (LocalBuilder)null) && CodeInstructionExtensions.Calls(list[i + 2], SetGlobalVector))
				{
					list.Insert(i + 2, LoadArgument(num));
					list.Insert(i + 3, new CodeInstruction(OpCodes.Call, (object)Hook("DepthToViewParams")));
					_depthToViewCount++;
					i += 3;
				}
			}
			return list;
		}

		private static CodeInstruction LoadArgument(int index)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			return (CodeInstruction)(index switch
			{
				0 => (object)new CodeInstruction(OpCodes.Ldarg_0, (object)null), 
				1 => (object)new CodeInstruction(OpCodes.Ldarg_1, (object)null), 
				2 => (object)new CodeInstruction(OpCodes.Ldarg_2, (object)null), 
				3 => (object)new CodeInstruction(OpCodes.Ldarg_3, (object)null), 
				_ => (object)new CodeInstruction(OpCodes.Ldarg_S, (object)(byte)index), 
			});
		}

		private static int CameraArgument(MethodBase method)
		{
			ParameterInfo[] parameters = method.GetParameters();
			for (int i = 0; i < parameters.Length; i++)
			{
				if (parameters[i].ParameterType == typeof(Camera))
				{
					if (!method.IsStatic)
					{
						return i + 1;
					}
					return i;
				}
			}
			return -1;
		}

		internal static void Verify()
		{
			bool num = (AmbientOcclusionPatches.EyePatchesApplied = _getterCount > 0 && _historyKeyCount > 0 && _depthToViewCount > 0);
			string text = $"{_getterCount} camera reads, {_historyKeyCount} history keys, " + $"{_depthToViewCount} view factor(s)";
			if (num)
			{
				Plugin.Log.LogInfo((object)("Ambient occlusion: draws for each eye in VR (" + text + ")."));
			}
			else
			{
				Plugin.Log.LogWarning((object)("Ambient occlusion: HTrace AO isn't the code SBGVR expects (" + text + "), so it's off in VR."));
			}
		}
	}
	internal static class EyeView
	{
		private static Camera _camera;

		private static int _eye;

		private static int _width;

		private static int _height;

		private static Matrix4x4 _projection;

		private static Matrix4x4 _view;

		private static int _loggedWidth;

		private static int _loggedHeight;

		internal static void Capture(ref RenderingData renderingData)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			ref CameraData cameraData = ref renderingData.cameraData;
			XRPass xr = ((CameraData)(ref cameraData)).xr;
			if (xr == null || !xr.enabled || xr.singlePassEnabled)
			{
				_camera = null;
				return;
			}
			RenderTextureDescriptor cameraTargetDescriptor = ((CameraData)(ref cameraData)).cameraTargetDescriptor;
			_camera = ((CameraData)(ref cameraData)).camera;
			_eye = xr.multipassId;
			_width = ((RenderTextureDescriptor)(ref cameraTargetDescriptor)).width;
			_height = ((RenderTextureDescriptor)(ref cameraTargetDescriptor)).height;
			_projection = ((CameraData)(ref cameraData)).GetProjectionMatrix(0);
			_view = ((CameraData)(ref cameraData)).GetViewMatrix(0);
			if (_width != _loggedWidth || _height != _loggedHeight)
			{
				_loggedWidth = _width;
				_loggedHeight = _height;
				Plugin.Log.LogInfo((object)$"Ambient occlusion: drawn for each eye at {_width}x{_height}.");
			}
		}

		private static bool IsEye(Camera camera)
		{
			if ((Object)(object)_camera != (Object)null)
			{
				return camera == _camera;
			}
			return false;
		}

		internal static int ScaledPixelWidth(Camera camera)
		{
			if (!IsEye(camera))
			{
				return camera.scaledPixelWidth;
			}
			return _width;
		}

		internal static int ScaledPixelHeight(Camera camera)
		{
			if (!IsEye(camera))
			{
				return camera.scaledPixelHeight;
			}
			return _height;
		}

		internal static int PixelHeight(Camera camera)
		{
			if (!IsEye(camera))
			{
				return camera.pixelHeight;
			}
			return _height;
		}

		internal static float FieldOfView(Camera camera)
		{
			if (!IsEye(camera))
			{
				return camera.fieldOfView;
			}
			return 2f * Mathf.Atan(1f / _projection.m11) * 57.29578f;
		}

		internal static Matrix4x4 ProjectionMatrix(Camera camera)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (!IsEye(camera))
			{
				return camera.projectionMatrix;
			}
			return _projection;
		}

		internal static Matrix4x4 NonJitteredProjectionMatrix(Camera camera)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (!IsEye(camera))
			{
				return camera.nonJitteredProjectionMatrix;
			}
			return _projection;
		}

		internal static Matrix4x4 WorldToCameraMatrix(Camera camera)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (!IsEye(camera))
			{
				return camera.worldToCameraMatrix;
			}
			return _view;
		}

		internal static int HistoryKey(object camera)
		{
			Camera val = (Camera)((camera is Camera) ? camera : null);
			if (val != null && IsEye(val))
			{
				return (((object)val).GetHashCode() * 397) ^ (_eye + 1);
			}
			return camera.GetHashCode();
		}

		internal static Vector4 DepthToViewParams(Vector4 original, Camera camera)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (!IsEye(camera))
			{
				return original;
			}
			Matrix4x4 projection = _projection;
			return new Vector4(2f / projection.m00, 2f / projection.m11, (0f - (1f - projection.m02)) / projection.m00, (0f - (1f - projection.m12)) / projection.m11);
		}
	}
	internal static class GuiZTest
	{
		internal const string Name = "unity_GUIZTestMode";

		internal static readonly int Id = Shader.PropertyToID("unity_GUIZTestMode");
	}
	[HarmonyPatch]
	internal static class StealthFramePatches
	{
		[HarmonyPatch(typeof(StealthFrameFeature), "AddRenderPasses")]
		[HarmonyPrefix]
		private static bool AddRenderPasses(ref RenderingData renderingData)
		{
			if (!VrState.IsRunning || !StealthFrameFeature.Enabled)
			{
				return true;
			}
			return !DrawsFloatingScreen(((CameraData)(ref renderingData.cameraData)).camera);
		}

		private static bool DrawsFloatingScreen(Camera camera)
		{
			if ((Object)(object)camera == (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)camera).GetComponent<ScreenMirrorPatchMode>() != (Object)null)
			{
				return true;
			}
			Transform parent = ((Component)camera).transform.parent;
			if ((Object)(object)parent != (Object)null)
			{
				return (Object)(object)((Component)parent).GetComponent<CanvasRedirectPatchMode>() != (Object)null;
			}
			return false;
		}
	}
}
namespace SBGVR.Hud
{
	[DefaultExecutionOrder(30001)]
	internal sealed class AimLine : MonoBehaviour
	{
		private const float WidthPerMetre = 0.0018f;

		private LineRenderer _line;

		private void Awake()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0097: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			GameObject val = new GameObject("SBGVR Aim Line");
			((Object)val).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)(object)val);
			_line = val.AddComponent<LineRenderer>();
			_line.useWorldSpace = true;
			_line.positionCount = 2;
			_line.alignment = (LineAlignment)0;
			_line.numCapVertices = 2;
			((Renderer)_line).shadowCastingMode = (ShadowCastingMode)0;
			((Renderer)_line).receiveShadows = false;
			((Renderer)_line).lightProbeUsage = (LightProbeUsage)0;
			((Renderer)_line).reflectionProbeUsage = (ReflectionProbeUsage)0;
			((Renderer)_line).allowOcclusionWhenDynamic = false;
			_line.startColor = Color.white;
			_line.endColor = Color.white;
			Material val2 = new Material(Canvas.GetDefaultCanvasMaterial())
			{
				name = "SBGVR aim line",
				color = Color.white,
				renderQueue = 3000
			};
			val2.SetInt(GuiZTest.Id, 4);
			((Renderer)_line).sharedMaterial = val2;
			((Renderer)_line).enabled = false;
		}

		private void OnDestroy()
		{
			if ((Object)(object)_line != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_line).gameObject);
			}
		}

		private void LateUpdate()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: 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)
			Vector3 start = Vector3.zero;
			Camera val = ((VrState.IsRunning && Settings.AimLine.Value && WorldReticles.AimShowing && TryGetStart(out start)) ? VrState.ViewCamera() : null);
			if ((Object)(object)val == (Object)null)
			{
				((Renderer)_line).enabled = false;
				return;
			}
			Vector3 aimPoint = WorldReticles.AimPoint;
			Vector3 position = ((Component)val).transform.position;
			_line.SetPosition(0, start);
			_line.SetPosition(1, aimPoint);
			float num = 0.0018f * RailgunScopeZoom.HudScale;
			_line.startWidth = num * Vector3.Distance(position, start);
			_line.endWidth = num * Vector3.Distance(position, aimPoint);
			((Renderer)_line).enabled = true;
		}

		private static bool TryGetStart(out Vector3 start)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			start = default(Vector3);
			PlayerInfo localPlayerInfo = GameManager.LocalPlayerInfo;
			if ((Object)(object)localPlayerInfo == (Object)null)
			{
				return false;
			}
			EquipmentSwitcher rightHandEquipmentSwitcher = localPlayerInfo.RightHandEquipmentSwitcher;
			start = (((Object)(object)rightHandEquipmentSwitcher != (Object)null) ? ((Component)rightHandEquipmentSwitcher).transform.position : (((Component)localPlayerInfo).transform.position + Vector3.up));
			return true;
		}
	}
	internal static class GameAimPoint
	{
		private const float MaxLocalYaw = 45f;

		private const float CrossCheckInterval = 1f;

		private const float CrossCheckTolerance = 0.01f;

		private static readonly RaycastHit[] Hits = (RaycastHit[])(object)new RaycastHit[100];

		private static readonly HashSet<ItemType> LoggedWeapons = new HashSet<ItemType>();

		private static readonly HashSet<ItemType> LoggedMismatches = new HashSet<ItemType>();

		private static readonly HashSet<string> LoggedErrors = new HashSet<string>();

		private static float _nextCrossCheck;

		private static bool _unavailable;

		internal static bool TryGet(out Vector3 point, out float range)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			point = default(Vector3);
			range = 0f;
			if (_unavailable)
			{
				return false;
			}
			try
			{
				return TryGetFromGame(out point, out range);
			}
			catch (Exception ex) when (ex is MissingMemberException || ex is TypeLoadException)
			{
				_unavailable = true;
				Plugin.Log.LogError((object)("Gun crosshairs: the game's aiming code has changed (" + ex.GetBaseException().Message + "). Gun crosshairs use SBGVR's own raycast instead."));
				return false;
			}
			catch (Exception ex2)
			{
				if (LoggedErrors.Add(ex2.GetType().FullName + ex2.Message))
				{
					Plugin.Log.LogWarning((object)$"Gun crosshairs: couldn't get the game's aim point: {ex2}");
				}
				return false;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static bool TryGetFromGame(out Vector3 point, out float range)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Invalid comparison between Unknown and I4
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Invalid comparison between Unknown and I4
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Invalid comparison between Unknown and I4
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Invalid comparison between Unknown and I4
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Invalid comparison between Unknown and I4
			//IL_0135: 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_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: 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_0171: Unknown result type (might be due to invalid IL or missing references)
			point = default(Vector3);
			range = 0f;
			PlayerInfo localPlayerInfo = GameManager.LocalPlayerInfo;
			ItemSettings itemSettings = GameManager.ItemSettings;
			LayerSettings layerSettings = GameManager.LayerSettings;
			if ((Object)(object)localPlayerInfo == (Object)null || (Object)(object)itemSettings == (Object)null || (Object)(object)layerSettings == (Object)null)
			{
				return false;
			}
			PlayerInventory inventory = localPlayerInfo.Inventory;
			if ((Object)(object)inventory == (Object)null)
			{
				return false;
			}
			ItemType networkedEquippedItem = localPlayerInfo.NetworkedEquippedItem;
			Vector3 val;
			Vector3 val2;
			int num;
			int num2;
			if ((int)networkedEquippedItem <= 3)
			{
				if ((int)networkedEquippedItem != 2)
				{
					if ((int)networkedEquippedItem != 3)
					{
						goto IL_0133;
					}
					val = inventory.GetElephantGunBarrelEndPosition();
					val2 = inventory.GetElephantGunBarrelForward();
					range = itemSettings.ElephantGunMaxAimingDistance;
					num = (num2 = LayerMask.op_Implicit(layerSettings.GunHittablesMask));
				}
				else
				{
					val = inventory.GetDuelingPistolBarrelEndPosition();
					val2 = inventory.GetDuelingPistolBarrelForward();
					range = itemSettings.DuelingPistolMaxAimingDistance;
					num = (num2 = LayerMask.op_Implicit(layerSettings.GunHittablesMask));
				}
			}
			else if ((int)networkedEquippedItem != 7)
			{
				if ((int)networkedEquippedItem != 16)
				{
					goto IL_0133;
				}
				val = inventory.GetRailgunBeamOriginPosition();
				val2 = inventory.GetRailgunBarrelForward();
				range = itemSettings.RailgunMaxAimingDistance;
				num = (num2 = LayerMask.op_Implicit(layerSettings.RailgunAimablesMask));
			}
			else
			{
				val = inventory.GetRocketLauncherBarrelFrontEndPosition();
				val2 = inventory.GetRocketLauncherBarrelForward();
				range = itemSettings.RocketLauncherMaxAimingDistance;
				num = LayerMask.op_Implicit(layerSettings.RocketHittablesMask);
				num2 = LayerMask.op_Implicit(layerSettings.GunHittablesMask);
			}
			LogWeapon(networkedEquippedItem, range, num, num2);
			float num3 = default(float);
			point = inventory.GetFirearmAimPoint(val, val2, range, num, ref num3);
			if (Mathf.Abs(num3) <= 45f)
			{
				CrossCheck(networkedEquippedItem, inventory, point, val, val2, range, num);
				return true;
			}
			point = AimWithoutTurnLimit(inventory, val, val2, range, num2);
			return true;
			IL_0133:
			return false;
		}

		private static Vector3 AimWithoutTurnLimit(PlayerInventory inventory, Vector3 backmost, Vector3 forward, float range, int layerMask)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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)
			Transform obj = ControllerAim.TransformOf((Component)(object)GameManager.Camera);
			Vector3 position = obj.position;
			Vector3 forward2 = obj.forward;
			int num = Physics.RaycastNonAlloc(new Ray(position, forward2), Hits, range, layerMask, (QueryTriggerInteraction)1);
			float num2 = float.MaxValue;
			Vector3 result = position + forward2 * range;
			for (int i = 0; i < num; i++)
			{
				RaycastHit val = Hits[i];
				if (!(((RaycastHit)(ref val)).distance >= num2) && !((Object)(object)((RaycastHit)(ref val)).collider == (Object)null) && !(Vector3.Dot(((RaycastHit)(ref val)).point - backmost, forward) <= 0f) && !((Object)(object)((Component)((RaycastHit)(ref val)).collider).GetComponentInParent<PlayerInventory>(true) == (Object)(object)inventory))
				{
					num2 = ((RaycastHit)(ref val)).distance;
					result = ((RaycastHit)(ref val)).point;
				}
			}
			return result;
		}

		private static void CrossCheck(ItemType weapon, PlayerInventory inventory, Vector3 gamePoint, Vector3 backmost, Vector3 forward, float range, int layerMask)
		{
			//IL_001d: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if (Settings.DiagnosticsEnabled.Value && !(Time.unscaledTime < _nextCrossCheck) && !LoggedMismatches.Contains(weapon))
			{
				_nextCrossCheck = Time.unscaledTime + 1f;
				float num = Vector3.Distance(AimWithoutTurnLimit(inventory, backmost, forward, range, layerMask), gamePoint);
				if (!(num <= 0.01f))
				{
					LoggedMismatches.Add(weapon);
					Plugin.Log.LogWarning((object)($"[diag] Gun crosshairs: SBGVR's copy of the game's aim for the {weapon} is {num:0.00} m off " + "the game's own; while aiming more than 45 degrees to the side, its crosshair may not be exact."));
				}
			}
		}

		private static void LogWeapon(ItemType weapon, float range, int layerMask, int layerMaskAfterTurning)
		{
			//IL_0011: 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)
			if (Settings.DiagnosticsEnabled.Value && LoggedWeapons.Add(weapon))
			{
				Plugin.Log.LogInfo((object)($"[diag] Gun crosshairs: the {weapon} aims up to {range:0.#} m, layers 0x{layerMask:X8}" + ((layerMaskAfterTurning != layerMask) ? $" (0x{layerMaskAfterTurning:X8} after turning)" : "") + "."));
			}
		}
	}
	internal static class MarkerOcclusion
	{
		private struct MarkerInView
		{
			internal WorldMarker Marker;

			internal Rect Area;

			internal float Distance;
		}

		private const int StencilBits = 8;

		private static readonly Dictionary<PlayerInfo, PlayerOccluder> Occluders = new Dictionary<PlayerInfo, PlayerOccluder>();

		private static readonly List<MarkerInView> Markers = new List<MarkerInView>();

		private static readonly List<PlayerOverlap.PlayerView> Covering = new List<PlayerOverlap.PlayerView>();

		private static readonly Dictionary<WorldMarker, int> Masks = new Dictionary<WorldMarker, int>();

		private static readonly Dictionary<PlayerOverlap.PlayerView, int> Bits = new Dictionary<PlayerOverlap.PlayerView, int>();

		private static readonly HashSet<PlayerInfo> Drawn = new HashSet<PlayerInfo>();

		private static readonly List<PlayerInfo> Gone = new List<PlayerInfo>();

		internal static void Initialize()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			_ = CanvasUpdateRegistry.instance;
			Canvas.willRenderCanvases += new WillRenderCanvases(OnWillRenderCanvases);
		}

		private static void OnWillRenderCanvases()
		{
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: 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)
			Camera val = ((WorldMarker.Enabled && Settings.MarkersOnTop.Value && Settings.PlayersCoverMarkers.Value) ? VrState.ViewCamera() : null);
			Markers.Clear();
			Covering.Clear();
			Masks.Clear();
			Bits.Clear();
			Drawn.Clear();
			Transform val2 = (((Object)(object)val != (Object)null) ? ((Component)val).transform : null);
			foreach (WorldMarker item in WorldMarker.InWorld)
			{
				if (!((Object)(object)item == (Object)null) && !((Object)(object)val == (Object)null) && !item.AlwaysOnTop && item.DrawnOnTop && item.TryGetArea(val2, out var area))
				{
					Markers.Add(new MarkerInView
					{
						Marker = item,
						Area = area,
						Distance = Vector3.Distance(val2.position, item.Position)
					});
				}
			}
			if (Markers.Count > 0)
			{
				foreach (PlayerOverlap.PlayerView item2 in PlayerOverlap.Update(val))
				{
					foreach (MarkerInView marker in Markers)
					{
						if (IsCovering(item2, marker))
						{
							Covering.Add(item2);
							break;
						}
					}
				}
				Covering.Sort((PlayerOverlap.PlayerView a, PlayerOverlap.PlayerView b) => a.Distance.CompareTo(b.Distance));
				for (int num = 0; num < Covering.Count; num++)
				{
					PlayerOverlap.PlayerView playerView = Covering[num];
					int num2 = 1 << Mathf.Min(num, 7);
					Bits[playerView] = num2;
					if (!Occluders.TryGetValue(playerView.Player, out var value))
					{
						value = new PlayerOccluder();
						Occluders[playerView.Player] = value;
					}
					value.Draw(playerView, num2);
					Drawn.Add(playerView.Player);
				}
				foreach (MarkerInView marker2 in Markers)
				{
					int num3 = 0;
					foreach (PlayerOverlap.PlayerView item3 in Covering)
					{
						if (IsCovering(item3, marker2))
						{
							num3 |= Bits[item3];
						}
					}
					if (num3 != 0)
					{
						Masks[marker2.Marker] = num3;
					}
				}
			}
			foreach (WorldMarker item4 in WorldMarker.InWorld)
			{
				if (!((Object)(object)item4 == (Object)null))
				{
					item4.SetCoveringMask(Masks.TryGetValue(item4, out var value2) ? value2 : 0);
					item4.EnforceDrawnMaterials();
				}
			}
			foreach (KeyValuePair<PlayerInfo, PlayerOccluder> occluder in Occluders)
			{
				if ((Object)(object)occluder.Key == (Object)null)
				{
					Gone.Add(occluder.Key);
				}
				else if (!Drawn.Contains(occluder.Key))
				{
					occluder.Value.Hide();
				}
			}
			foreach (PlayerInfo item5 in Gone)
			{
				Occluders[item5].Dispose();
				Occluders.Remove(item5);
			}
			Gone.Clear();
		}

		private static bool IsCovering(PlayerOverlap.PlayerView player, MarkerInView marker)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player.Player != (Object)(object)marker.Marker.Owner && player.Distance < marker.Distance)
			{
				return player.Overlaps(marker.Area);
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class MarkerPatches
	{
		[HarmonyPatch(typeof(WorldspaceIconUi), "LateUpdate")]
		[HarmonyPostfix]
		private static void IconLateUpdate(WorldspaceIconUi __instance, Vector3 ___worldPosition, bool ___isOffscreen, Transform ___parent, WorldspaceIconUiSettings ___settings)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			bool flag = WorldMarker.Enabled && !___isOffscreen;
			PlayerInfo owner = ((flag && (Object)(object)___parent != (Object)null && (Object)(object)___settings == (Object)(object)WorldspaceIconManager.TeammateIconSettings) ? ((Component)___parent).GetComponentInParent<PlayerInfo>() : null);
			WorldMarker.Place((Component)(object)__instance, ___worldPosition, flag, owner);
		}

		[HarmonyPatch(typeof(NameTagUi), "LateUpdate")]
		[HarmonyPostfix]
		private static void NameTagLateUpdate(NameTagUi __instance, Vector3 ___worldPosition, PlayerInfo ___playerInfo, bool ___nameTagIsPlayer)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			WorldMarker.Place((Component)(object)__instance, ___worldPosition, WorldMarker.Enabled, ___nameTagIsPlayer ? ___playerInfo : null);
		}

		[HarmonyPatch(typeof(TargetReticleUi), "LateUpdate")]
		[HarmonyPostfix]
		private static void ReticleLateUpdate(UiVisibilityController ___reticleVisibilityController, ButtonPrompt ___interactButtonPrompt, Vector3 ___lastInteractableReticleWorldPosition)
		{
			//IL_0001: 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)
			WorldMarker.Place((Component)(object)___reticleVisibilityController, ___lastInteractableReticleWorldPosition, WorldMarker.Enabled);
			WorldMarker.Place((Component)(object)___interactButtonPrompt, ___lastInteractableReticleWorldPosition, WorldMarker.Enabled);
		}
	}
	[HarmonyPatch]
	internal static class MarkerViewAnglePatches
	{
		private const string LocalFunctionPrefix = "<LateUpdate>g__IsOffscreen|";

		private static MethodBase TargetMethod()
		{
			return AccessTools.GetDeclaredMethods(typeof(WorldspaceIconUi)).FirstOrDefault((MethodInfo m) => m.Name.StartsWith("<LateUpdate>g__IsOffscreen|", StringComparison.Ordinal) && m.ReturnType == typeof(bool)) ?? throw new MissingMethodException("WorldspaceIconUi", "<LateUpdate>g__IsOffscreen|...");
		}

		private static bool Prefix(Vector3 ___worldPosition, ref bool __result)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (!WorldMarker.Enabled)
			{
				return true;
			}
			Camera camera = GameManager.Camera;
			if ((Object)(object)camera == (Object)null)
			{
				return true;
			}
			Vector3 val = ___worldPosition - ((Component)camera).transform.position;
			__result = Vector3.Angle(((Component)camera).transform.forward, val) > Settings.MarkerViewAngle.Value;
			return false;
		}
	}
	internal enum MenuControlsSide
	{
		Below,
		Left,
		Right
	}
	internal sealed class MenuControlsPanel : MonoBehaviour
	{
		private const string ImageResource = "SBGVR.controller-layout.png";

		private const string MirroredImageResource = "SBGVR.controller-layout-mirrored.png";

		private const int RenderQueue = 5000;

		private const int OrdersAfterScreen = 2;

		private const float WidthPerMetre = 0.95f;

		private const float GapDegrees = 4f;

		private GameObject _panel;

		private Material _material;

		private Texture2D _texture;

		private Texture2D _mirroredTexture;

		private bool _showingMirrored;

		private bool _mirroredFailed;

		private float _aspect = 55f / 72f;

		private bool _failed;

		private string _loggedWhere;

		private void OnEnable()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			Application.onBeforeRender += new UnityAction(Place);
		}

		private void OnDisable()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			Application.onBeforeRender -= new UnityAction(Place);
			if ((Object)(object)_panel != (Object)null)
			{
				_panel.SetActive(false);
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)_panel != (Object)null)
			{
				Object.Destroy((Object)(object)_panel);
			}
			if ((Object)(object)_material != (Object)null)
			{
				Object.Destroy((Object)(object)_material);
			}
			if ((Object)(object)_texture != (Object)null)
			{
				Object.Destroy((Object)(object)_texture);
			}
			if ((Object)(object)_mirroredTexture != (Object)null)
			{
				Object.Destroy((Object)(object)_mirroredTexture);
			}
		}

		private void LateUpdate()
		{
			Place();
		}

		private static string ShowingFor()
		{
			if (!VrState.IsRunning || !Settings.MenuControls.Value || !Settings.MotionControls.Value)
			{
				return null;
			}
			if (SingletonBehaviour<MainMenu>.HasInstance)
			{
				return "the main menu";
			}
			if (PauseMenu.IsPaused)
			{
				return "the pause menu";
			}
			return null;
		}

		private void Place()
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			if (_failed)
			{
				return;
			}
			string text = ShowingFor();
			Camera val = ((text != null) ? VrState.ViewCamera() : null);
			if ((Object)(object)val == (Object)null)
			{
				if ((Object)(object)_panel != (Object)null && _panel.activeSelf)
				{
					_panel.SetActive(false);
				}
			}
			else if (!((Object)(object)_panel == (Object)null) || Create())
			{
				ShowLayout(Settings.MirrorButtons.Value);
				ModConfiguration instance = ModConfiguration.Instance;
				Vector3 value = instance.VrUiPosition.Value;
				float num = Mathf.Max(0.3f, Mathf.Abs(value.z));
				float num2 = 1.8f * instance.VrUiScale.Value / 2f;
				float num3 = num2 * (float)Screen.height / (float)Mathf.Max(1, Screen.width);
				float num4 = 0.95f * num;
				MenuControlsSide value2 = Settings.MenuControlsSide.Value;
				float num7;
				Quaternion val2;
				Vector3 val3 = default(Vector3);
				if (value2 == MenuControlsSide.Below)
				{
					float num5 = Mathf.Atan2(value.y - num3, n