using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Bhaptics.Tact;
using EntityStates;
using EntityStates.Bandit2.Weapon;
using EntityStates.Captain.Weapon;
using EntityStates.Commando;
using EntityStates.Commando.CommandoWeapon;
using EntityStates.Croco;
using EntityStates.Engi.EngiMissilePainter;
using EntityStates.Engi.EngiWeapon;
using EntityStates.GlobalSkills.LunarNeedle;
using EntityStates.Huntress;
using EntityStates.Huntress.HuntressWeapon;
using EntityStates.LaserTurbine;
using EntityStates.Loader;
using EntityStates.Mage;
using EntityStates.Mage.Weapon;
using EntityStates.Merc;
using EntityStates.Railgunner.Scope;
using EntityStates.Railgunner.Weapon;
using EntityStates.Seeker;
using EntityStates.Toolbot;
using EntityStates.Treebot.Weapon;
using EntityStates.VagrantNovaItem;
using EntityStates.VoidSurvivor;
using EntityStates.VoidSurvivor.Weapon;
using HG;
using HG.GeneralSerializer;
using IL.EntityStates.GlobalSkills.LunarNeedle;
using IL.EntityStates.Toolbot;
using IL.RoR2;
using IL.RoR2.CameraModes;
using IL.RoR2.UI;
using LIV.SDK.Unity;
using LeTai.Asset.TranslucentImage;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using On.EntityStates;
using On.EntityStates.Bandit2.Weapon;
using On.EntityStates.Captain.Weapon;
using On.EntityStates.Commando.CommandoWeapon;
using On.EntityStates.Croco;
using On.EntityStates.Engi.EngiMissilePainter;
using On.EntityStates.Engi.EngiWeapon;
using On.EntityStates.Huntress;
using On.EntityStates.Huntress.HuntressWeapon;
using On.EntityStates.LaserTurbine;
using On.EntityStates.Loader;
using On.EntityStates.Mage.Weapon;
using On.EntityStates.Merc;
using On.EntityStates.Railgunner.Scope;
using On.EntityStates.Railgunner.Weapon;
using On.EntityStates.Seeker;
using On.EntityStates.Toolbot;
using On.EntityStates.Treebot.Weapon;
using On.EntityStates.VagrantNovaItem;
using On.EntityStates.VoidSurvivor;
using On.RoR2;
using On.RoR2.CameraModes;
using On.RoR2.GamepadVibration;
using On.RoR2.Networking;
using On.RoR2.Projectile;
using On.RoR2.RemoteGameBrowser;
using On.RoR2.UI;
using On.RoR2.UI.LogBook;
using On.RoR2.UI.MainMenu;
using Rewired;
using Rewired.Data;
using Rewired.Data.Mapping;
using Rewired.Utils.Classes.Data;
using RoR2;
using RoR2.CameraModes;
using RoR2.GamepadVibration;
using RoR2.HudOverlay;
using RoR2.Networking;
using RoR2.PostProcess;
using RoR2.Projectile;
using RoR2.RemoteGameBrowser;
using RoR2.Skills;
using RoR2.UI;
using RoR2.UI.LogBook;
using RoR2.UI.MainMenu;
using TMPro;
using ThreeEyedGames;
using Unity.XR.CoreUtils;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.Networking;
using UnityEngine.Playables;
using UnityEngine.Rendering;
using UnityEngine.Rendering.PostProcessing;
using UnityEngine.SceneManagement;
using UnityEngine.Serialization;
using UnityEngine.SpatialTracking;
using UnityEngine.UI;
using UnityEngine.XR;
using UnityEngine.XR.Interaction.Toolkit;
using UnityEngine.XR.Management;
using UnityEngine.XR.OpenXR;
using UnityEngine.XR.OpenXR.Features;
using UnityEngine.XR.OpenXR.Features.Interactions;
using VRMod;
using VRMod.Haptics;
using VRMod.Inputs;
using VRMod.Properties;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace LIV.SDK.Unity
{
	[Flags]
	public enum INVALIDATION_FLAGS : uint
	{
		NONE = 0u,
		HMD_CAMERA = 1u,
		STAGE = 2u,
		MR_CAMERA_PREFAB = 4u,
		EXCLUDE_BEHAVIOURS = 8u
	}
	[HelpURL("https://liv.tv/sdk-unity-docs")]
	[AddComponentMenu("LIV/LIV")]
	public class LIV : MonoBehaviour
	{
		public Action onActivate;

		public Action<SDKRender> onPreRender;

		public Action<SDKRender> onPreRenderBackground;

		public Action<SDKRender> onPostRenderBackground;

		public Action<SDKRender> onPreRenderForeground;

		public Action<SDKRender> onPostRenderForeground;

		public Action<SDKRender> onPostRender;

		public Action onDeactivate;

		[Tooltip("This is the topmost transform of your VR rig.")]
		[FormerlySerializedAs("TrackedSpaceOrigin")]
		[SerializeField]
		private Transform _stage;

		[Tooltip("This transform is an additional wrapper to the user’s playspace.")]
		[FormerlySerializedAs("StageTransform")]
		[SerializeField]
		private Transform _stageTransform;

		[Tooltip("This is the camera responsible for rendering the user’s HMD.")]
		[FormerlySerializedAs("HMDCamera")]
		[SerializeField]
		private Camera _HMDCamera;

		[Tooltip("Camera prefab for customized rendering.")]
		[FormerlySerializedAs("MRCameraPrefab")]
		[SerializeField]
		private Camera _MRCameraPrefab;

		[Tooltip("This option disables all standard Unity assets for the Mixed Reality rendering.")]
		[FormerlySerializedAs("DisableStandardAssets")]
		[SerializeField]
		private bool _disableStandardAssets;

		[Tooltip("The layer mask defines exactly which object layers should be rendered in MR.")]
		[FormerlySerializedAs("SpectatorLayerMask")]
		[SerializeField]
		private LayerMask _spectatorLayerMask = LayerMask.op_Implicit(-1);

		[Tooltip("This is for removing unwanted scripts from the cloned MR camera.")]
		[FormerlySerializedAs("ExcludeBehaviours")]
		[SerializeField]
		private string[] _excludeBehaviours = new string[5] { "AudioListener", "Collider", "SteamVR_Camera", "SteamVR_Fade", "SteamVR_ExternalCamera" };

		[Tooltip("Recovers corrupted alpha channel when using post-effects.")]
		[FormerlySerializedAs("FixPostEffectsAlpha")]
		[SerializeField]
		private bool _fixPostEffectsAlpha;

		private bool _isActive;

		private SDKRender _render;

		private bool _wasReady;

		private INVALIDATION_FLAGS _invalidate;

		private Transform _stageCandidate;

		private Camera _HMDCameraCandidate;

		private Camera _MRCameraPrefabCandidate;

		private string[] _excludeBehavioursCandidate;

		private bool _enabled;

		private Coroutine _waitForEndOfFrameCoroutine;

		public Transform stage
		{
			get
			{
				if (!((Object)(object)_stage == (Object)null))
				{
					return _stage;
				}
				return ((Component)this).transform.parent;
			}
			set
			{
				if ((Object)(object)value == (Object)null)
				{
					Debug.LogWarning((object)"LIV: Stage cannot be null!");
				}
				if ((Object)(object)_stage != (Object)(object)value)
				{
					_stageCandidate = value;
					_invalidate = (INVALIDATION_FLAGS)SDKUtils.SetFlag((ulong)_invalidate, 2uL, enabled: true);
				}
			}
		}

		[Obsolete("Use stage instead")]
		public Transform trackedSpaceOrigin
		{
			get
			{
				return stage;
			}
			set
			{
				stage = value;
			}
		}

		public Matrix4x4 stageLocalToWorldMatrix
		{
			get
			{
				//IL_001a: 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)
				if (!((Object)(object)stage != (Object)null))
				{
					return Matrix4x4.identity;
				}
				return stage.localToWorldMatrix;
			}
		}

		public Matrix4x4 stageWorldToLocalMatrix
		{
			get
			{
				//IL_001a: 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)
				if (!((Object)(object)stage != (Object)null))
				{
					return Matrix4x4.identity;
				}
				return stage.worldToLocalMatrix;
			}
		}

		public Transform stageTransform
		{
			get
			{
				return _stageTransform;
			}
			set
			{
				_stageTransform = value;
			}
		}

		public Camera HMDCamera
		{
			get
			{
				return _HMDCamera;
			}
			set
			{
				if ((Object)(object)value == (Object)null)
				{
					Debug.LogWarning((object)"LIV: HMD Camera cannot be null!");
				}
				if ((Object)(object)_HMDCamera != (Object)(object)value)
				{
					_HMDCameraCandidate = value;
					_invalidate = (INVALIDATION_FLAGS)SDKUtils.SetFlag((ulong)_invalidate, 1uL, enabled: true);
				}
			}
		}

		public Camera MRCameraPrefab
		{
			get
			{
				return _MRCameraPrefab;
			}
			set
			{
				if ((Object)(object)_MRCameraPrefab != (Object)(object)value)
				{
					_MRCameraPrefabCandidate = value;
					_invalidate = (INVALIDATION_FLAGS)SDKUtils.SetFlag((ulong)_invalidate, 4uL, enabled: true);
				}
			}
		}

		public bool disableStandardAssets
		{
			get
			{
				return _disableStandardAssets;
			}
			set
			{
				_disableStandardAssets = value;
			}
		}

		public LayerMask spectatorLayerMask
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return _spectatorLayerMask;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				_spectatorLayerMask = value;
			}
		}

		public string[] excludeBehaviours
		{
			get
			{
				return _excludeBehaviours;
			}
			set
			{
				if (_excludeBehaviours != value)
				{
					_excludeBehavioursCandidate = value;
					_invalidate = (INVALIDATION_FLAGS)SDKUtils.SetFlag((ulong)_invalidate, 8uL, enabled: true);
				}
			}
		}

		public bool fixPostEffectsAlpha
		{
			get
			{
				return _fixPostEffectsAlpha;
			}
			set
			{
				_fixPostEffectsAlpha = value;
			}
		}

		public bool isValid
		{
			get
			{
				if (_invalidate != INVALIDATION_FLAGS.NONE)
				{
					return false;
				}
				if ((Object)(object)_HMDCamera == (Object)null)
				{
					return false;
				}
				return true;
			}
		}

		public bool isActive => _isActive;

		private bool _isReady
		{
			get
			{
				if (isValid && _enabled)
				{
					return SDKBridge.IsActive;
				}
				return false;
			}
		}

		public SDKRender render => _render;

		private void Awake()
		{
			((Behaviour)this).enabled = false;
		}

		private void OnEnable()
		{
			_enabled = true;
			UpdateSDKReady();
		}

		private void Update()
		{
			UpdateSDKReady();
			Invalidate();
		}

		private void OnDisable()
		{
			_enabled = false;
			UpdateSDKReady();
		}

		private IEnumerator WaitForUnityEndOfFrame()
		{
			while (Application.isPlaying && ((Behaviour)this).enabled)
			{
				yield return (object)new WaitForEndOfFrame();
				if (isActive)
				{
					_render.Render();
				}
			}
		}

		private void UpdateSDKReady()
		{
			bool isReady = _isReady;
			if (isReady != _wasReady)
			{
				OnSDKReadyChanged(isReady);
				_wasReady = isReady;
			}
		}

		private void OnSDKReadyChanged(bool value)
		{
			if (value)
			{
				OnSDKActivate();
			}
			else
			{
				OnSDKDeactivate();
			}
		}

		private void OnSDKActivate()
		{
			Debug.Log((object)"LIV: Compositor connected, setting up Mixed Reality!");
			SubmitSDKOutput();
			CreateAssets();
			StartRenderCoroutine();
			_isActive = true;
			if (onActivate != null)
			{
				onActivate();
			}
		}

		private void OnSDKDeactivate()
		{
			Debug.Log((object)"LIV: Compositor disconnected, cleaning up Mixed Reality.");
			if (onDeactivate != null)
			{
				onDeactivate();
			}
			StopRenderCoroutine();
			DestroyAssets();
			_isActive = false;
			if (Object.op_Implicit((Object)(object)UIFixes.livHUD))
			{
				Object.Destroy((Object)(object)((Component)UIFixes.livHUD).gameObject);
			}
		}

		private void CreateAssets()
		{
			DestroyAssets();
			_render = new SDKRender(this);
			if (ModConfig.LIVHUD.Value)
			{
				UIFixes.CreateLIVHUD(_render.uiCameraInstance);
			}
		}

		private void DestroyAssets()
		{
			if (_render != null)
			{
				_render.Dispose();
				_render = null;
			}
		}

		private void StartRenderCoroutine()
		{
			StopRenderCoroutine();
			_waitForEndOfFrameCoroutine = ((MonoBehaviour)this).StartCoroutine(WaitForUnityEndOfFrame());
		}

		private void StopRenderCoroutine()
		{
			if (_waitForEndOfFrameCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_waitForEndOfFrameCoroutine);
				_waitForEndOfFrameCoroutine = null;
			}
		}

		private void SubmitSDKOutput()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			SDKApplicationOutput empty = SDKApplicationOutput.empty;
			empty.supportedFeatures = FEATURES.BACKGROUND_RENDER | FEATURES.FOREGROUND_RENDER | FEATURES.OVERRIDE_POST_PROCESSING | FEATURES.FIX_FOREGROUND_ALPHA;
			empty.sdkID = "UT4QDBPGHQZHTDVOSRUHN1PZZCM187WV";
			empty.sdkVersion = "1.5.4";
			empty.engineName = "unity";
			empty.engineVersion = Application.unityVersion;
			empty.applicationName = Application.productName;
			empty.applicationVersion = Application.version;
			empty.graphicsAPI = ((object)SystemInfo.graphicsDeviceType/*cast due to .constrained prefix*/).ToString();
			empty.xrDeviceName = XRSettings.loadedDeviceName;
			SDKBridge.SubmitApplicationOutput(empty);
		}

		private void Invalidate()
		{
			if (SDKUtils.ContainsFlag((ulong)_invalidate, 2uL))
			{
				_stage = _stageCandidate;
				_stageCandidate = null;
				_invalidate = (INVALIDATION_FLAGS)SDKUtils.SetFlag((ulong)_invalidate, 2uL, enabled: false);
			}
			if (SDKUtils.ContainsFlag((ulong)_invalidate, 1uL))
			{
				_HMDCamera = _HMDCameraCandidate;
				_HMDCameraCandidate = null;
				_invalidate = (INVALIDATION_FLAGS)SDKUtils.SetFlag((ulong)_invalidate, 1uL, enabled: false);
			}
			if (SDKUtils.ContainsFlag((ulong)_invalidate, 4uL))
			{
				_MRCameraPrefab = _MRCameraPrefabCandidate;
				_MRCameraPrefabCandidate = null;
				_invalidate = (INVALIDATION_FLAGS)SDKUtils.SetFlag((ulong)_invalidate, 4uL, enabled: false);
			}
			if (SDKUtils.ContainsFlag((ulong)_invalidate, 8uL))
			{
				_excludeBehaviours = _excludeBehavioursCandidate;
				_excludeBehavioursCandidate = null;
				_invalidate = (INVALIDATION_FLAGS)SDKUtils.SetFlag((ulong)_invalidate, 8uL, enabled: false);
			}
		}
	}
	public static class SDKBridge
	{
		public struct SDKInjection<T>
		{
			public bool active;

			public Action action;

			public T data;
		}

		private static SDKInjection<SDKInputFrame> _injection_SDKInputFrame = new SDKInjection<SDKInputFrame>
		{
			active = false,
			action = null,
			data = SDKInputFrame.empty
		};

		private static SDKInjection<SDKResolution> _injection_SDKResolution = new SDKInjection<SDKResolution>
		{
			active = false,
			action = null,
			data = SDKResolution.zero
		};

		private static SDKInjection<bool> _injection_IsActive = new SDKInjection<bool>
		{
			active = false,
			action = null,
			data = false
		};

		private static bool _injection_DisableSubmit = false;

		private static bool _injection_DisableSubmitApplicationOutput = false;

		private static bool _injection_DisableAddTexture = false;

		private static bool _injection_DisableCreateFrame = false;

		public static bool IsActive
		{
			get
			{
				if (_injection_IsActive.active)
				{
					return _injection_IsActive.data;
				}
				return GetIsCaptureActive();
			}
		}

		[DllImport("LIV_Bridge")]
		private static extern IntPtr GetRenderEventFunc();

		[DllImport("LIV_Bridge", EntryPoint = "LivCaptureIsActive")]
		[return: MarshalAs(UnmanagedType.U1)]
		private static extern bool GetIsCaptureActive();

		[DllImport("LIV_Bridge", EntryPoint = "LivCaptureWidth")]
		private static extern int GetTextureWidth();

		[DllImport("LIV_Bridge", EntryPoint = "LivCaptureHeight")]
		private static extern int GetTextureHeight();

		[DllImport("LIV_Bridge", EntryPoint = "LivCaptureSetTextureFromUnity")]
		private static extern void SetTexture(IntPtr texture);

		[DllImport("LIV_Bridge")]
		public static extern int AcquireCompositorFrame(ulong timestamp);

		[DllImport("LIV_Bridge")]
		public static extern int ReleaseCompositorFrame();

		[DllImport("LIV_Bridge")]
		public static extern ulong GetObjectTimeStamp(IntPtr obj);

		[DllImport("LIV_Bridge")]
		private static extern ulong GetCurrentTimeTicks();

		[DllImport("LIV_Bridge")]
		public static extern ulong GetObjectTag(IntPtr obj);

		[DllImport("LIV_Bridge")]
		public static extern IntPtr GetCompositorFrameObject(ulong tag);

		[DllImport("LIV_Bridge")]
		public static extern IntPtr GetViewportTexture();

		[DllImport("LIV_Bridge")]
		public static extern IntPtr GetCompositorChannelObject(int slot, ulong tag, ulong timestamp);

		[DllImport("LIV_Bridge")]
		public static extern IntPtr GetChannelObject(int slot, ulong tag, ulong timestamp);

		[DllImport("LIV_Bridge")]
		public static extern int AddObjectToChannel(int slot, IntPtr obj, int objectsize, ulong tag);

		[DllImport("LIV_Bridge")]
		public static extern int AddObjectToCompositorChannel(int slot, IntPtr obj, int objectsize, ulong tag);

		[DllImport("LIV_Bridge")]
		public static extern int AddObjectToFrame(IntPtr obj, int objectsize, ulong tag);

		[DllImport("LIV_Bridge", EntryPoint = "AddObjectToFrame")]
		public static extern int AddStringToFrame(IntPtr str, ulong tag);

		[DllImport("LIV_Bridge")]
		public static extern int AddStringToChannel(int slot, IntPtr str, int length, ulong tag);

		[DllImport("LIV_Bridge")]
		public static extern int NewFrame();

		[DllImport("LIV_Bridge")]
		public static extern IntPtr CommitFrame();

		[DllImport("LIV_Bridge")]
		public static extern int addsharedtexture(int width, int height, int format, IntPtr sourcetexture, ulong tag);

		[DllImport("LIV_Bridge")]
		public static extern int addtexture(IntPtr sourcetexture, ulong tag);

		[DllImport("LIV_Bridge")]
		public static extern void PublishTextures();

		[DllImport("LIV_Bridge", EntryPoint = "updateinputframe")]
		public static extern IntPtr updatinputframe(IntPtr InputFrame);

		[DllImport("LIV_Bridge")]
		public static extern IntPtr setinputframe(float x, float y, float z, float q0, float q1, float q2, float q3, float fov, int priority);

		[DllImport("LIV_Bridge")]
		public static extern ulong setfeature(ulong feature);

		[DllImport("LIV_Bridge")]
		public static extern ulong clearfeature(ulong feature);

		public static ulong Tag(string str)
		{
			ulong num = 0uL;
			for (int i = 0; i < str.Length && i != 8; i++)
			{
				char c = str[i];
				num |= (ulong)((long)(c & 0xFF) << i * 8);
			}
			return num;
		}

		public static void AddString(string tag, string value, int slot)
		{
			byte[] bytes = Encoding.UTF8.GetBytes(value);
			GCHandle gCHandle = GCHandle.Alloc(bytes, GCHandleType.Pinned);
			AddStringToChannel(slot, Marshal.UnsafeAddrOfPinnedArrayElement(bytes, 0), bytes.Length, Tag(tag));
			gCHandle.Free();
		}

		public static void AddTexture(SDKTexture texture, ulong tag)
		{
			GCHandle gCHandle = GCHandle.Alloc(texture, GCHandleType.Pinned);
			addtexture(gCHandle.AddrOfPinnedObject(), tag);
			gCHandle.Free();
		}

		public static ulong GetObjectTime(IntPtr objectptr)
		{
			return GetObjectTimeStamp(objectptr) + 621355968000000000L;
		}

		public static ulong GetCurrentTime()
		{
			return GetCurrentTimeTicks() + 621355968000000000L;
		}

		public static void IssuePluginEvent()
		{
			if (!_injection_DisableSubmit)
			{
				GL.IssuePluginEvent(GetRenderEventFunc(), 2);
			}
		}

		public static void SubmitApplicationOutput(SDKApplicationOutput applicationOutput)
		{
			if (!_injection_DisableSubmitApplicationOutput)
			{
				AddString("APPNAME", applicationOutput.applicationName, 5);
				AddString("APPVER", applicationOutput.applicationVersion, 5);
				AddString("ENGNAME", applicationOutput.engineName, 5);
				AddString("ENGVER", applicationOutput.engineVersion, 5);
				AddString("GFXAPI", applicationOutput.graphicsAPI, 5);
				AddString("SDKID", applicationOutput.sdkID, 5);
				AddString("SDKVER", applicationOutput.sdkVersion, 5);
				AddString("SUPPORT", applicationOutput.supportedFeatures.ToString(), 5);
				AddString("XRNAME", applicationOutput.xrDeviceName, 5);
			}
		}

		public static bool GetStructFromGlobalChannel<T>(ref T mystruct, int channel, ulong tag)
		{
			IntPtr compositorChannelObject = GetCompositorChannelObject(channel, tag, ulong.MaxValue);
			if (compositorChannelObject == IntPtr.Zero)
			{
				return false;
			}
			mystruct = (T)Marshal.PtrToStructure(compositorChannelObject, typeof(T));
			return true;
		}

		public static int AddStructToGlobalChannel<T>(ref T mystruct, int channel, ulong tag)
		{
			GCHandle gCHandle = GCHandle.Alloc(mystruct, GCHandleType.Pinned);
			int result = AddObjectToCompositorChannel(channel, gCHandle.AddrOfPinnedObject(), Marshal.SizeOf(mystruct), tag);
			gCHandle.Free();
			return result;
		}

		public static bool GetStructFromLocalChannel<T>(ref T mystruct, int channel, ulong tag)
		{
			IntPtr channelObject = GetChannelObject(channel, tag, ulong.MaxValue);
			if (channelObject == IntPtr.Zero)
			{
				return false;
			}
			mystruct = (T)Marshal.PtrToStructure(channelObject, typeof(T));
			return true;
		}

		public static int AddStructToLocalChannel<T>(ref T mystruct, int channel, ulong tag)
		{
			GCHandle gCHandle = GCHandle.Alloc(mystruct, GCHandleType.Pinned);
			int result = AddObjectToChannel(channel, gCHandle.AddrOfPinnedObject(), Marshal.SizeOf(mystruct), tag);
			gCHandle.Free();
			return result;
		}

		public static void AddStructToFrame<T>(ref T mystruct, ulong tag)
		{
			GCHandle gCHandle = GCHandle.Alloc(mystruct, GCHandleType.Pinned);
			AddObjectToFrame(gCHandle.AddrOfPinnedObject(), Marshal.SizeOf(mystruct), tag);
			gCHandle.Free();
		}

		public static bool UpdateInputFrame(ref SDKInputFrame setframe)
		{
			if (_injection_SDKInputFrame.active && _injection_SDKInputFrame.action != null)
			{
				_injection_SDKInputFrame.action();
				setframe = _injection_SDKInputFrame.data;
			}
			else
			{
				GCHandle gCHandle = GCHandle.Alloc(setframe, GCHandleType.Pinned);
				IntPtr intPtr = updatinputframe(gCHandle.AddrOfPinnedObject());
				gCHandle.Free();
				if (intPtr == IntPtr.Zero)
				{
					setframe = SDKInputFrame.empty;
					return false;
				}
				setframe = (SDKInputFrame)Marshal.PtrToStructure(intPtr, typeof(SDKInputFrame));
				_injection_SDKInputFrame.data = setframe;
			}
			return true;
		}

		public static SDKTexture GetViewfinderTexture()
		{
			_ = SDKTexture.empty;
			IntPtr compositorChannelObject = GetCompositorChannelObject(11, Tag("OUTTEX"), ulong.MaxValue);
			if (compositorChannelObject == IntPtr.Zero)
			{
				return default(SDKTexture);
			}
			return (SDKTexture)Marshal.PtrToStructure(compositorChannelObject, typeof(SDKTexture));
		}

		public static void AddTexture(SDKTexture texture)
		{
			if (!_injection_DisableAddTexture)
			{
				string str = "";
				switch (texture.id)
				{
				case TEXTURE_ID.BACKGROUND_COLOR_BUFFER_ID:
					str = "BGCTEX";
					break;
				case TEXTURE_ID.FOREGROUND_COLOR_BUFFER_ID:
					str = "FGCTEX";
					break;
				case TEXTURE_ID.OPTIMIZED_COLOR_BUFFER_ID:
					str = "OPTTEX";
					break;
				}
				AddTexture(texture, Tag(str));
			}
		}

		public static void CreateFrame(SDKOutputFrame frame)
		{
			if (!_injection_DisableCreateFrame)
			{
				GCHandle gCHandle = GCHandle.Alloc(frame, GCHandleType.Pinned);
				AddObjectToFrame(gCHandle.AddrOfPinnedObject(), Marshal.SizeOf(frame), Tag("OUTFRAME"));
				gCHandle.Free();
			}
		}

		public static void SetGroundPlane(SDKPlane groundPlane)
		{
			AddStructToGlobalChannel(ref groundPlane, 2, Tag("SetGND"));
		}

		public static bool GetResolution(ref SDKResolution sdkResolution)
		{
			if (_injection_SDKResolution.active && _injection_SDKResolution.action != null)
			{
				_injection_SDKResolution.action();
				sdkResolution = _injection_SDKResolution.data;
				return true;
			}
			bool structFromLocalChannel = GetStructFromLocalChannel(ref sdkResolution, 15, Tag("SDKRes"));
			_injection_SDKResolution.data = sdkResolution;
			return structFromLocalChannel;
		}
	}
	public class SDKRender : IDisposable
	{
		private CommandBuffer _clipPlaneCommandBuffer;

		private CommandBuffer _combineAlphaCommandBuffer;

		private CommandBuffer _captureTextureCommandBuffer;

		private CommandBuffer _applyTextureCommandBuffer;

		private CommandBuffer _optimizedRenderingCommandBuffer;

		private CameraEvent _clipPlaneCameraEvent = (CameraEvent)11;

		private CameraEvent _clipPlaneCombineAlphaCameraEvent = (CameraEvent)20;

		private CameraEvent _captureTextureEvent = (CameraEvent)18;

		private CameraEvent _applyTextureEvent = (CameraEvent)20;

		private CameraEvent _optimizedRenderingCameraEvent = (CameraEvent)20;

		private Mesh _clipPlaneMesh;

		private Material _clipPlaneSimpleMaterial;

		private Material _clipPlaneSimpleDebugMaterial;

		private Material _clipPlaneComplexMaterial;

		private Material _clipPlaneComplexDebugMaterial;

		private Material _writeOpaqueToAlphaMaterial;

		private Material _combineAlphaMaterial;

		private Material _writeMaterial;

		private Material _forceForwardRenderingMaterial;

		private Material _uiTransparentMaterial;

		private RenderTexture _backgroundRenderTexture;

		private RenderTexture _uiRenderTexture;

		private RenderTexture _foregroundRenderTexture;

		private RenderTexture _optimizedRenderTexture;

		private RenderTexture _complexClipPlaneRenderTexture;

		private bool uiRendered;

		private LIV _liv;

		private SDKOutputFrame _outputFrame = SDKOutputFrame.empty;

		private SDKInputFrame _inputFrame = SDKInputFrame.empty;

		private SDKResolution _resolution = SDKResolution.zero;

		private Camera _cameraInstance;

		private Camera _uiCameraInstance;

		private PostProcessLayer _cameraPostProcess;

		private SDKPose _requestedPose = SDKPose.empty;

		private int _requestedPoseFrameIndex;

		private bool useDeferredRendering
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Invalid comparison between Unknown and I4
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Invalid comparison between Unknown and I4
				if ((int)_cameraInstance.actualRenderingPath != 2)
				{
					return (int)_cameraInstance.actualRenderingPath == 3;
				}
				return true;
			}
		}

		private bool interlacedRendering => SDKUtils.FeatureEnabled(inputFrame.features, FEATURES.INTERLACED_RENDER);

		private bool canRenderBackground
		{
			get
			{
				if (interlacedRendering && Time.frameCount % 2 != 0)
				{
					return false;
				}
				if (SDKUtils.FeatureEnabled(inputFrame.features, FEATURES.BACKGROUND_RENDER))
				{
					return (Object)(object)_backgroundRenderTexture != (Object)null;
				}
				return false;
			}
		}

		private bool canRenderForeground
		{
			get
			{
				if (interlacedRendering && Time.frameCount % 2 != 1)
				{
					return false;
				}
				if (SDKUtils.FeatureEnabled(inputFrame.features, FEATURES.FOREGROUND_RENDER))
				{
					return (Object)(object)_foregroundRenderTexture != (Object)null;
				}
				return false;
			}
		}

		private bool canRenderOptimized
		{
			get
			{
				if (SDKUtils.FeatureEnabled(inputFrame.features, FEATURES.OPTIMIZED_RENDER))
				{
					return (Object)(object)_optimizedRenderTexture != (Object)null;
				}
				return false;
			}
		}

		public LIV liv => _liv;

		public SDKOutputFrame outputFrame => _outputFrame;

		public SDKInputFrame inputFrame => _inputFrame;

		public SDKResolution resolution => _resolution;

		public Camera cameraInstance => _cameraInstance;

		public Camera uiCameraInstance => _uiCameraInstance;

		public PostProcessLayer cameraPostProcess => _cameraPostProcess;

		public Camera cameraReference
		{
			get
			{
				if (!((Object)(object)_liv.MRCameraPrefab == (Object)null))
				{
					return _liv.MRCameraPrefab;
				}
				return _liv.HMDCamera;
			}
		}

		public Camera hmdCamera => _liv.HMDCamera;

		public Transform stage => _liv.stage;

		public Transform stageTransform => _liv.stageTransform;

		public Matrix4x4 stageLocalToWorldMatrix
		{
			get
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)_liv.stage == (Object)null))
				{
					return _liv.stage.localToWorldMatrix;
				}
				return Matrix4x4.identity;
			}
		}

		public Matrix4x4 localToWorldMatrix
		{
			get
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)_liv.stageTransform == (Object)null))
				{
					return _liv.stageTransform.localToWorldMatrix;
				}
				return stageLocalToWorldMatrix;
			}
		}

		public int spectatorLayerMask => LayerMask.op_Implicit(_liv.spectatorLayerMask);

		public bool disableStandardAssets => _liv.disableStandardAssets;

		public bool canSetPose
		{
			get
			{
				if (_inputFrame.frameid == 0L)
				{
					return false;
				}
				return _inputFrame.priority.pose <= 63;
			}
		}

		private Material GetClipPlaneMaterial(bool debugClipPlane, bool complexClipPlane, ColorWriteMask colorWriteMask)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected I4, but got Unknown
			Material val;
			if (complexClipPlane)
			{
				val = (debugClipPlane ? _clipPlaneComplexDebugMaterial : _clipPlaneComplexMaterial);
				val.SetTexture(SDKShaders.LIV_CLIP_PLANE_HEIGHT_MAP_PROPERTY, (Texture)(object)_complexClipPlaneRenderTexture);
				val.SetFloat(SDKShaders.LIV_TESSELLATION_PROPERTY, _inputFrame.clipPlane.tesselation);
			}
			else
			{
				val = (debugClipPlane ? _clipPlaneSimpleDebugMaterial : _clipPlaneSimpleMaterial);
			}
			val.SetInt(SDKShaders.LIV_COLOR_MASK, (int)colorWriteMask);
			return val;
		}

		private Material GetGroundClipPlaneMaterial(bool debugClipPlane, ColorWriteMask colorWriteMask)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected I4, but got Unknown
			Material obj = (debugClipPlane ? _clipPlaneSimpleDebugMaterial : _clipPlaneSimpleMaterial);
			obj.SetInt(SDKShaders.LIV_COLOR_MASK, (int)colorWriteMask);
			return obj;
		}

		public SDKRender(LIV liv)
		{
			//IL_0003: 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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			_liv = liv;
			CreateAssets();
		}

		public void Render()
		{
			UpdateBridgeResolution();
			UpdateBridgeInputFrame();
			SDKUtils.ApplyUserSpaceTransform(this);
			UpdateTextures();
			InvokePreRender();
			RenderUI();
			if (canRenderBackground)
			{
				RenderBackground();
			}
			if (canRenderForeground)
			{
				RenderForeground();
			}
			if (canRenderOptimized)
			{
				RenderOptimized();
			}
			IvokePostRender();
			SDKUtils.CreateBridgeOutputFrame(this);
			SDKBridge.IssuePluginEvent();
		}

		private void RenderUI()
		{
			uiRendered = false;
			if (Object.op_Implicit((Object)(object)_uiCameraInstance) && Object.op_Implicit((Object)(object)_uiRenderTexture))
			{
				_uiCameraInstance.targetTexture = _uiRenderTexture;
				_uiCameraInstance.Render();
				uiRendered = true;
				_uiCameraInstance.targetTexture = null;
				_uiTransparentMaterial.mainTexture = (Texture)(object)_uiRenderTexture;
			}
		}

		private void RenderBackground()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			SDKUtils.SetCamera(_cameraInstance, ((Component)_cameraInstance).transform, _inputFrame, localToWorldMatrix, spectatorLayerMask);
			_cameraInstance.targetTexture = _backgroundRenderTexture;
			RenderTexture val = null;
			bool num = SDKUtils.FeatureEnabled(inputFrame.features, FEATURES.OVERRIDE_POST_PROCESSING);
			if (num)
			{
				val = RenderTexture.GetTemporary(((Texture)_backgroundRenderTexture).width, ((Texture)_backgroundRenderTexture).height, 0, _backgroundRenderTexture.format);
				_captureTextureCommandBuffer.Blit(RenderTargetIdentifier.op_Implicit((BuiltinRenderTextureType)1), RenderTargetIdentifier.op_Implicit((Texture)(object)val));
				_applyTextureCommandBuffer.Blit((Texture)(object)val, RenderTargetIdentifier.op_Implicit((BuiltinRenderTextureType)1));
				_cameraInstance.AddCommandBuffer(_captureTextureEvent, _captureTextureCommandBuffer);
				_cameraInstance.AddCommandBuffer(_applyTextureEvent, _applyTextureCommandBuffer);
			}
			SDKShaders.StartRendering();
			SDKShaders.StartBackgroundRendering();
			InvokePreRenderBackground();
			SendTextureToBridge(_backgroundRenderTexture, TEXTURE_ID.BACKGROUND_COLOR_BUFFER_ID);
			_cameraInstance.Render();
			if (uiRendered)
			{
				Graphics.Blit((Texture)(object)_uiRenderTexture, _backgroundRenderTexture, _uiTransparentMaterial);
			}
			InvokePostRenderBackground();
			_cameraInstance.targetTexture = null;
			SDKShaders.StopBackgroundRendering();
			SDKShaders.StopRendering();
			if (num)
			{
				_cameraInstance.RemoveCommandBuffer(_captureTextureEvent, _captureTextureCommandBuffer);
				_cameraInstance.RemoveCommandBuffer(_applyTextureEvent, _applyTextureCommandBuffer);
				_captureTextureCommandBuffer.Clear();
				_applyTextureCommandBuffer.Clear();
				RenderTexture.ReleaseTemporary(val);
			}
		}

		private void RenderForeground()
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: 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_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0403: Unknown result type (might be due to invalid IL or missing references)
			//IL_041a: Unknown result type (might be due to invalid IL or missing references)
			//IL_044d: Unknown result type (might be due to invalid IL or missing references)
			//IL_045a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0461: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cf: Unknown result type (might be due to invalid IL or missing references)
			bool debugClipPlane = SDKUtils.FeatureEnabled(inputFrame.features, FEATURES.DEBUG_CLIP_PLANE);
			bool complexClipPlane = SDKUtils.FeatureEnabled(inputFrame.features, FEATURES.COMPLEX_CLIP_PLANE);
			bool num = SDKUtils.FeatureEnabled(inputFrame.features, FEATURES.GROUND_CLIP_PLANE);
			bool flag = SDKUtils.FeatureEnabled(inputFrame.features, FEATURES.OVERRIDE_POST_PROCESSING);
			bool flag2 = SDKUtils.FeatureEnabled(inputFrame.features, FEATURES.FIX_FOREGROUND_ALPHA) | _liv.fixPostEffectsAlpha;
			if (Object.op_Implicit((Object)(object)_cameraPostProcess))
			{
				((Behaviour)_cameraPostProcess).enabled = false;
			}
			MonoBehaviour[] behaviours = null;
			bool[] wasBehaviourEnabled = null;
			if (disableStandardAssets)
			{
				SDKUtils.DisableStandardAssets(_cameraInstance, ref behaviours, ref wasBehaviourEnabled);
			}
			CameraClearFlags clearFlags = _cameraInstance.clearFlags;
			Color backgroundColor = _cameraInstance.backgroundColor;
			Color fogColor = RenderSettings.fogColor;
			RenderSettings.fogColor = new Color(fogColor.r, fogColor.g, fogColor.b, 0f);
			SDKUtils.SetCamera(_cameraInstance, ((Component)_cameraInstance).transform, _inputFrame, localToWorldMatrix, spectatorLayerMask);
			_cameraInstance.clearFlags = (CameraClearFlags)2;
			_cameraInstance.backgroundColor = Color.clear;
			_cameraInstance.targetTexture = _foregroundRenderTexture;
			RenderTexture temporary = RenderTexture.GetTemporary(((Texture)_foregroundRenderTexture).width, ((Texture)_foregroundRenderTexture).height, 0, _foregroundRenderTexture.format);
			_clipPlaneCommandBuffer.DrawMesh(_clipPlaneMesh, Matrix4x4.identity, _writeOpaqueToAlphaMaterial, 0, 0);
			Matrix4x4 val = localToWorldMatrix * (Matrix4x4)_inputFrame.clipPlane.transform;
			_clipPlaneCommandBuffer.DrawMesh(_clipPlaneMesh, val, GetClipPlaneMaterial(debugClipPlane, complexClipPlane, (ColorWriteMask)15), 0, 0);
			if (num)
			{
				Matrix4x4 val2 = localToWorldMatrix * (Matrix4x4)_inputFrame.groundClipPlane.transform;
				_clipPlaneCommandBuffer.DrawMesh(_clipPlaneMesh, val2, GetGroundClipPlaneMaterial(debugClipPlane, (ColorWriteMask)15), 0, 0);
			}
			_clipPlaneCommandBuffer.Blit(RenderTargetIdentifier.op_Implicit((BuiltinRenderTextureType)1), RenderTargetIdentifier.op_Implicit((Texture)(object)temporary));
			_cameraInstance.AddCommandBuffer(_clipPlaneCameraEvent, _clipPlaneCommandBuffer);
			RenderTexture val3 = null;
			if (flag || flag2)
			{
				val3 = RenderTexture.GetTemporary(((Texture)_foregroundRenderTexture).width, ((Texture)_foregroundRenderTexture).height, 0, _foregroundRenderTexture.format);
				_captureTextureCommandBuffer.Blit(RenderTargetIdentifier.op_Implicit((BuiltinRenderTextureType)1), RenderTargetIdentifier.op_Implicit((Texture)(object)val3));
				_cameraInstance.AddCommandBuffer(_captureTextureEvent, _captureTextureCommandBuffer);
				_writeMaterial.SetInt(SDKShaders.LIV_COLOR_MASK, (!flag) ? 1 : 15);
				_applyTextureCommandBuffer.Blit((Texture)(object)val3, RenderTargetIdentifier.op_Implicit((BuiltinRenderTextureType)1), _writeMaterial);
				_cameraInstance.AddCommandBuffer(_applyTextureEvent, _applyTextureCommandBuffer);
			}
			_combineAlphaMaterial.SetInt(SDKShaders.LIV_COLOR_MASK, 1);
			_combineAlphaCommandBuffer.Blit((Texture)(object)temporary, RenderTargetIdentifier.op_Implicit((BuiltinRenderTextureType)1), _combineAlphaMaterial);
			_cameraInstance.AddCommandBuffer(_clipPlaneCombineAlphaCameraEvent, _combineAlphaCommandBuffer);
			if (useDeferredRendering)
			{
				SDKUtils.ForceForwardRendering(cameraInstance, _clipPlaneMesh, _forceForwardRenderingMaterial);
			}
			SDKShaders.StartRendering();
			SDKShaders.StartForegroundRendering();
			InvokePreRenderForeground();
			SendTextureToBridge(_foregroundRenderTexture, TEXTURE_ID.FOREGROUND_COLOR_BUFFER_ID);
			_cameraInstance.Render();
			if (uiRendered)
			{
				Graphics.Blit((Texture)(object)_uiRenderTexture, _foregroundRenderTexture, _uiTransparentMaterial);
			}
			InvokePostRenderForeground();
			_cameraInstance.targetTexture = null;
			SDKShaders.StopForegroundRendering();
			SDKShaders.StopRendering();
			if (flag || flag2)
			{
				_cameraInstance.RemoveCommandBuffer(_captureTextureEvent, _captureTextureCommandBuffer);
				_cameraInstance.RemoveCommandBuffer(_applyTextureEvent, _applyTextureCommandBuffer);
				_captureTextureCommandBuffer.Clear();
				_applyTextureCommandBuffer.Clear();
				RenderTexture.ReleaseTemporary(val3);
			}
			_cameraInstance.RemoveCommandBuffer(_clipPlaneCameraEvent, _clipPlaneCommandBuffer);
			_cameraInstance.RemoveCommandBuffer(_clipPlaneCombineAlphaCameraEvent, _combineAlphaCommandBuffer);
			RenderTexture.ReleaseTemporary(temporary);
			_clipPlaneCommandBuffer.Clear();
			_combineAlphaCommandBuffer.Clear();
			_cameraInstance.clearFlags = clearFlags;
			_cameraInstance.backgroundColor = backgroundColor;
			RenderSettings.fogColor = fogColor;
			SDKUtils.RestoreStandardAssets(ref behaviours, ref wasBehaviourEnabled);
			if (Object.op_Implicit((Object)(object)_cameraPostProcess))
			{
				((Behaviour)_cameraPostProcess).enabled = true;
			}
		}

		private void RenderOptimized()
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: 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_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			bool debugClipPlane = SDKUtils.FeatureEnabled(inputFrame.features, FEATURES.DEBUG_CLIP_PLANE);
			bool complexClipPlane = SDKUtils.FeatureEnabled(inputFrame.features, FEATURES.COMPLEX_CLIP_PLANE);
			bool num = SDKUtils.FeatureEnabled(inputFrame.features, FEATURES.GROUND_CLIP_PLANE);
			SDKUtils.SetCamera(_cameraInstance, ((Component)_cameraInstance).transform, _inputFrame, localToWorldMatrix, spectatorLayerMask);
			_cameraInstance.targetTexture = _optimizedRenderTexture;
			_writeMaterial.SetInt(SDKShaders.LIV_COLOR_MASK, 1);
			_optimizedRenderingCommandBuffer.Blit(RenderTargetIdentifier.op_Implicit((BuiltinRenderTextureType)0), RenderTargetIdentifier.op_Implicit((BuiltinRenderTextureType)1), _writeMaterial);
			_writeOpaqueToAlphaMaterial.SetInt(SDKShaders.LIV_COLOR_MASK, 1);
			_optimizedRenderingCommandBuffer.DrawMesh(_clipPlaneMesh, Matrix4x4.identity, _writeOpaqueToAlphaMaterial, 0, 0);
			Matrix4x4 val = localToWorldMatrix * (Matrix4x4)_inputFrame.clipPlane.transform;
			_optimizedRenderingCommandBuffer.DrawMesh(_clipPlaneMesh, val, GetClipPlaneMaterial(debugClipPlane, complexClipPlane, (ColorWriteMask)1), 0, 0);
			if (num)
			{
				Matrix4x4 val2 = localToWorldMatrix * (Matrix4x4)_inputFrame.groundClipPlane.transform;
				_optimizedRenderingCommandBuffer.DrawMesh(_clipPlaneMesh, val2, GetGroundClipPlaneMaterial(debugClipPlane, (ColorWriteMask)1), 0, 0);
			}
			_cameraInstance.AddCommandBuffer((CameraEvent)20, _optimizedRenderingCommandBuffer);
			SDKShaders.StartRendering();
			SDKShaders.StartBackgroundRendering();
			InvokePreRenderBackground();
			SendTextureToBridge(_optimizedRenderTexture, TEXTURE_ID.OPTIMIZED_COLOR_BUFFER_ID);
			_cameraInstance.Render();
			if (uiRendered)
			{
				Graphics.Blit((Texture)(object)_uiRenderTexture, _backgroundRenderTexture, _uiTransparentMaterial);
			}
			InvokePostRenderBackground();
			_cameraInstance.targetTexture = null;
			SDKShaders.StopBackgroundRendering();
			SDKShaders.StopRendering();
			_cameraInstance.RemoveCommandBuffer((CameraEvent)20, _optimizedRenderingCommandBuffer);
			_optimizedRenderingCommandBuffer.Clear();
		}

		private void CreateAssets()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Expected O, but got Unknown
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Expected O, but got Unknown
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Expected O, but got Unknown
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Expected O, but got Unknown
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Expected O, but got Unknown
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Expected O, but got Unknown
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Expected O, but got Unknown
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Expected O, but got Unknown
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Expected O, but got Unknown
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Expected O, but got Unknown
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Expected O, but got Unknown
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Expected O, but got Unknown
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Expected O, but got Unknown
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Expected O, but got Unknown
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Expected O, but got Unknown
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			bool enabled = ((Behaviour)cameraReference).enabled;
			if (enabled)
			{
				((Behaviour)cameraReference).enabled = false;
			}
			bool activeSelf = ((Component)cameraReference).gameObject.activeSelf;
			if (activeSelf)
			{
				((Component)cameraReference).gameObject.SetActive(false);
			}
			GameObject val = Object.Instantiate<GameObject>(((Component)cameraReference).gameObject, _liv.stage);
			_cameraInstance = (Camera)val.GetComponent("Camera");
			SDKUtils.CleanCameraBehaviours(_cameraInstance, _liv.excludeBehaviours);
			if (activeSelf != ((Component)cameraReference).gameObject.activeSelf)
			{
				((Component)cameraReference).gameObject.SetActive(activeSelf);
			}
			if (enabled != ((Behaviour)cameraReference).enabled)
			{
				((Behaviour)cameraReference).enabled = enabled;
			}
			((Object)_cameraInstance).name = "LIV Camera";
			if (((Component)_cameraInstance).tag == "MainCamera")
			{
				((Component)_cameraInstance).tag = "Untagged";
			}
			((Component)_cameraInstance).transform.localScale = Vector3.one;
			_cameraInstance.rect = new Rect(0f, 0f, 1f, 1f);
			_cameraInstance.depth = 0f;
			_cameraInstance.stereoTargetEye = (StereoTargetEyeMask)0;
			_cameraInstance.allowMSAA = false;
			((Behaviour)_cameraInstance).enabled = false;
			((Component)_cameraInstance).gameObject.SetActive(true);
			((Component)_cameraInstance).GetComponent<SceneCamera>().cameraRigController = ((Component)cameraReference).GetComponent<SceneCamera>().cameraRigController;
			_cameraPostProcess = ((Component)_cameraInstance).GetComponent<PostProcessLayer>();
			_clipPlaneMesh = new Mesh();
			SDKUtils.CreateClipPlane(_clipPlaneMesh, 10, 10, useQuads: true, 1000f);
			_clipPlaneSimpleMaterial = new Material(SDKShaders.clipPlaneSimpleMaterial);
			_clipPlaneSimpleDebugMaterial = new Material(SDKShaders.clipPlaneSimpleDebugMaterial);
			_clipPlaneComplexMaterial = new Material(SDKShaders.clipPlaneComplexMaterial);
			_clipPlaneComplexDebugMaterial = new Material(SDKShaders.clipPlaneComplexDebugMaterial);
			_writeOpaqueToAlphaMaterial = new Material(SDKShaders.writeOpaqueToAlphaMaterial);
			_combineAlphaMaterial = new Material(SDKShaders.combineAlphaMaterial);
			_writeMaterial = new Material(SDKShaders.writeMaterial);
			_forceForwardRenderingMaterial = new Material(SDKShaders.forceForwardRenderingMaterial);
			_uiTransparentMaterial = global::VRMod.VRMod.VRAssetBundle.LoadAsset<Material>("UnlitTransparentMat");
			_clipPlaneCommandBuffer = new CommandBuffer();
			_combineAlphaCommandBuffer = new CommandBuffer();
			_captureTextureCommandBuffer = new CommandBuffer();
			_applyTextureCommandBuffer = new CommandBuffer();
			_optimizedRenderingCommandBuffer = new CommandBuffer();
			GameObject val2 = new GameObject("LIV UI Camera");
			val2.transform.SetParent(((Component)_cameraInstance).transform);
			val2.transform.localPosition = Vector3.zero;
			val2.transform.localRotation = Quaternion.identity;
			val2.transform.localScale = Vector3.one;
			_uiCameraInstance = val2.AddComponent<Camera>();
			_uiCameraInstance.cullingMask = 1 << LayerIndex.triggerZone.intVal;
			_uiCameraInstance.clearFlags = (CameraClearFlags)2;
			_uiCameraInstance.backgroundColor = new Color(0f, 0f, 0f, 0f);
			_uiCameraInstance.rect = new Rect(0f, 0f, 1f, 1f);
			_uiCameraInstance.depth = 1f;
			_uiCameraInstance.stereoTargetEye = (StereoTargetEyeMask)0;
			_uiCameraInstance.allowHDR = false;
			_uiCameraInstance.allowMSAA = false;
			((Behaviour)_uiCameraInstance).enabled = false;
			((Component)_uiCameraInstance).gameObject.SetActive(true);
		}

		private void DestroyAssets()
		{
			if ((Object)(object)_cameraInstance != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_cameraInstance).gameObject);
				_cameraInstance = null;
			}
			SDKUtils.DestroyObject<Mesh>(ref _clipPlaneMesh);
			SDKUtils.DestroyObject<Material>(ref _clipPlaneSimpleMaterial);
			SDKUtils.DestroyObject<Material>(ref _clipPlaneSimpleDebugMaterial);
			SDKUtils.DestroyObject<Material>(ref _clipPlaneComplexMaterial);
			SDKUtils.DestroyObject<Material>(ref _clipPlaneComplexDebugMaterial);
			SDKUtils.DestroyObject<Material>(ref _writeOpaqueToAlphaMaterial);
			SDKUtils.DestroyObject<Material>(ref _combineAlphaMaterial);
			SDKUtils.DestroyObject<Material>(ref _writeMaterial);
			SDKUtils.DestroyObject<Material>(ref _forceForwardRenderingMaterial);
			SDKUtils.DisposeObject<CommandBuffer>(ref _clipPlaneCommandBuffer);
			SDKUtils.DisposeObject<CommandBuffer>(ref _combineAlphaCommandBuffer);
			SDKUtils.DisposeObject<CommandBuffer>(ref _captureTextureCommandBuffer);
			SDKUtils.DisposeObject<CommandBuffer>(ref _applyTextureCommandBuffer);
			SDKUtils.DisposeObject<CommandBuffer>(ref _optimizedRenderingCommandBuffer);
		}

		public void Dispose()
		{
			ReleaseBridgePoseControl();
			DestroyAssets();
			SDKUtils.DestroyTexture(ref _backgroundRenderTexture);
			SDKUtils.DestroyTexture(ref _uiRenderTexture);
			SDKUtils.DestroyTexture(ref _foregroundRenderTexture);
			SDKUtils.DestroyTexture(ref _optimizedRenderTexture);
			SDKUtils.DestroyTexture(ref _complexClipPlaneRenderTexture);
		}

		public bool SetPose(Vector3 position, Quaternion rotation, float verticalFieldOfView = 60f, bool useLocalSpace = false)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			if (_inputFrame.frameid == 0L)
			{
				return false;
			}
			SDKPose pose = _inputFrame.pose;
			float num = 1f;
			if (_resolution.height > 0)
			{
				num = (float)_resolution.width / (float)_resolution.height;
			}
			if (!useLocalSpace)
			{
				Matrix4x4 matrix = Matrix4x4.identity;
				Transform val = (((Object)(object)stageTransform == (Object)null) ? stage : stageTransform);
				if ((Object)(object)val != (Object)null)
				{
					matrix = val.worldToLocalMatrix;
				}
				position = ((Matrix4x4)(ref matrix)).MultiplyPoint(position);
				rotation = SDKUtils.RotateQuaternionByMatrix(matrix, rotation);
			}
			_requestedPose = new SDKPose
			{
				localPosition = position,
				localRotation = rotation,
				verticalFieldOfView = verticalFieldOfView,
				projectionMatrix = Matrix4x4.Perspective(verticalFieldOfView, num, pose.nearClipPlane, pose.farClipPlane)
			};
			_requestedPoseFrameIndex = Time.frameCount;
			return _inputFrame.priority.pose <= 63;
		}

		public void SetGroundPlane(float distance, Vector3 normal, bool useLocalSpace = false)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			float distance2 = distance;
			Vector3 val = normal;
			if (!useLocalSpace)
			{
				Matrix4x4 worldToLocalMatrix = (((Object)(object)stageTransform == (Object)null) ? stage : stageTransform).worldToLocalMatrix;
				Vector3 val2 = ((Matrix4x4)(ref worldToLocalMatrix)).MultiplyPoint(normal * distance);
				val = ((Matrix4x4)(ref worldToLocalMatrix)).MultiplyVector(normal);
				distance2 = 0f - Vector3.Dot(normal, val2);
			}
			SDKBridge.SetGroundPlane(new SDKPlane
			{
				distance = distance2,
				normal = val
			});
		}

		public void SetGroundPlane(Plane plane, bool useLocalSpace = false)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			SetGroundPlane(((Plane)(ref plane)).distance, ((Plane)(ref plane)).normal, useLocalSpace);
		}

		public void SetGroundPlane(Transform transform, bool useLocalSpace = false)
		{
			//IL_0016: 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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)transform == (Object)null))
			{
				Quaternion val = (useLocalSpace ? transform.localRotation : transform.rotation);
				Vector3 val2 = (useLocalSpace ? transform.localPosition : transform.position);
				Vector3 val3 = val * Vector3.up;
				SetGroundPlane(0f - Vector3.Dot(val3, val2), val3, useLocalSpace);
			}
		}

		private void ReleaseBridgePoseControl()
		{
			_inputFrame.ReleaseControl();
			SDKBridge.UpdateInputFrame(ref _inputFrame);
		}

		private void UpdateBridgeResolution()
		{
			SDKBridge.GetResolution(ref _resolution);
		}

		private void UpdateBridgeInputFrame()
		{
			if (_requestedPoseFrameIndex == Time.frameCount)
			{
				_inputFrame.ObtainControl();
				_inputFrame.pose = _requestedPose;
				_requestedPose = SDKPose.empty;
			}
			else
			{
				_inputFrame.ReleaseControl();
			}
			if ((Object)(object)_cameraInstance != (Object)null)
			{
				_inputFrame.pose.nearClipPlane = _cameraInstance.nearClipPlane;
				_inputFrame.pose.farClipPlane = _cameraInstance.farClipPlane;
			}
			SDKBridge.UpdateInputFrame(ref _inputFrame);
		}

		private void InvokePreRender()
		{
			if (_liv.onPreRender != null)
			{
				_liv.onPreRender(this);
			}
		}

		private void IvokePostRender()
		{
			if (_liv.onPostRender != null)
			{
				_liv.onPostRender(this);
			}
		}

		private void InvokePreRenderBackground()
		{
			if (_liv.onPreRenderBackground != null)
			{
				_liv.onPreRenderBackground(this);
			}
		}

		private void InvokePostRenderBackground()
		{
			if (_liv.onPostRenderBackground != null)
			{
				_liv.onPostRenderBackground(this);
			}
		}

		private void InvokePreRenderForeground()
		{
			if (_liv.onPreRenderForeground != null)
			{
				_liv.onPreRenderForeground(this);
			}
		}

		private void InvokePostRenderForeground()
		{
			if (_liv.onPostRenderForeground != null)
			{
				_liv.onPostRenderForeground(this);
			}
		}

		private void CreateBackgroundTexture()
		{
			if (!SDKUtils.CreateTexture(ref _backgroundRenderTexture, _resolution.width, _resolution.height, 24, (RenderTextureFormat)0))
			{
				Debug.LogError((object)"LIV: Unable to create background texture!");
			}
		}

		private void CreateUITexture()
		{
			if (!SDKUtils.CreateTexture(ref _uiRenderTexture, _resolution.width, _resolution.height, 24, (RenderTextureFormat)0))
			{
				Debug.LogError((object)"LIV: Unable to create UI texture!");
			}
		}

		private void CreateForegroundTexture()
		{
			if (!SDKUtils.CreateTexture(ref _foregroundRenderTexture, _resolution.width, _resolution.height, 24, (RenderTextureFormat)0))
			{
				Debug.LogError((object)"LIV: Unable to create foreground texture!");
			}
		}

		private void CreateOptimizedTexture()
		{
			if (!SDKUtils.CreateTexture(ref _optimizedRenderTexture, _resolution.width, _resolution.height, 24, (RenderTextureFormat)0))
			{
				Debug.LogError((object)"LIV: Unable to create optimized texture!");
			}
		}

		private void CreateComplexClipPlaneTexture()
		{
			if (!SDKUtils.CreateTexture(ref _complexClipPlaneRenderTexture, _inputFrame.clipPlane.width, _inputFrame.clipPlane.height, 0, (RenderTextureFormat)0))
			{
				Debug.LogError((object)"LIV: Unable to create complex clip plane texture!");
			}
		}

		private void UpdateTextures()
		{
			if (SDKUtils.FeatureEnabled(inputFrame.features, FEATURES.BACKGROUND_RENDER))
			{
				if ((Object)(object)_backgroundRenderTexture == (Object)null || ((Texture)_backgroundRenderTexture).width != _resolution.width || ((Texture)_backgroundRenderTexture).height != _resolution.height)
				{
					CreateBackgroundTexture();
				}
			}
			else
			{
				SDKUtils.DestroyTexture(ref _backgroundRenderTexture);
			}
			if ((Object)(object)_uiRenderTexture == (Object)null || ((Texture)_uiRenderTexture).width != _resolution.width || ((Texture)_uiRenderTexture).height != _resolution.height)
			{
				CreateUITexture();
			}
			if (SDKUtils.FeatureEnabled(inputFrame.features, FEATURES.FOREGROUND_RENDER))
			{
				if ((Object)(object)_foregroundRenderTexture == (Object)null || ((Texture)_foregroundRenderTexture).width != _resolution.width || ((Texture)_foregroundRenderTexture).height != _resolution.height)
				{
					CreateForegroundTexture();
				}
			}
			else
			{
				SDKUtils.DestroyTexture(ref _foregroundRenderTexture);
			}
			if (SDKUtils.FeatureEnabled(inputFrame.features, FEATURES.OPTIMIZED_RENDER))
			{
				if ((Object)(object)_optimizedRenderTexture == (Object)null || ((Texture)_optimizedRenderTexture).width != _resolution.width || ((Texture)_optimizedRenderTexture).height != _resolution.height)
				{
					CreateOptimizedTexture();
				}
			}
			else
			{
				SDKUtils.DestroyTexture(ref _optimizedRenderTexture);
			}
			if (SDKUtils.FeatureEnabled(inputFrame.features, FEATURES.COMPLEX_CLIP_PLANE))
			{
				if ((Object)(object)_complexClipPlaneRenderTexture == (Object)null || ((Texture)_complexClipPlaneRenderTexture).width != _inputFrame.clipPlane.width || ((Texture)_complexClipPlaneRenderTexture).height != _inputFrame.clipPlane.height)
				{
					CreateComplexClipPlaneTexture();
				}
			}
			else
			{
				SDKUtils.DestroyTexture(ref _complexClipPlaneRenderTexture);
			}
		}

		private void SendTextureToBridge(RenderTexture texture, TEXTURE_ID id)
		{
			SDKBridge.AddTexture(new SDKTexture
			{
				id = id,
				texturePtr = ((Texture)texture).GetNativeTexturePtr(),
				SharedHandle = IntPtr.Zero,
				device = SDKUtils.GetDevice(),
				dummy = 0,
				type = TEXTURE_TYPE.COLOR_BUFFER,
				format = TEXTURE_FORMAT.ARGB32,
				colorSpace = SDKUtils.GetColorSpace(texture),
				width = ((Texture)texture).width,
				height = ((Texture)texture).height
			});
		}
	}
	internal static class SDKShaders
	{
		public static readonly int LIV_COLOR_MASK = Shader.PropertyToID("_LivColorMask");

		public static readonly int LIV_TESSELLATION_PROPERTY = Shader.PropertyToID("_LivTessellation");

		public static readonly int LIV_CLIP_PLANE_HEIGHT_MAP_PROPERTY = Shader.PropertyToID("_LivClipPlaneHeightMap");

		public const string LIV_MR_FOREGROUND_KEYWORD = "LIV_MR_FOREGROUND";

		public const string LIV_MR_BACKGROUND_KEYWORD = "LIV_MR_BACKGROUND";

		public const string LIV_MR_KEYWORD = "LIV_MR";

		public static Material clipPlaneSimpleMaterial { get; private set; }

		public static Material clipPlaneSimpleDebugMaterial { get; private set; }

		public static Material clipPlaneComplexMaterial { get; private set; }

		public static Material clipPlaneComplexDebugMaterial { get; private set; }

		public static Material writeOpaqueToAlphaMaterial { get; private set; }

		public static Material combineAlphaMaterial { get; private set; }

		public static Material writeMaterial { get; private set; }

		public static Material forceForwardRenderingMaterial { get; private set; }

		public static void LoadShaders()
		{
			clipPlaneSimpleMaterial = global::VRMod.VRMod.VRAssetBundle.LoadAsset<Material>("LIV_ClipPlaneSimpleMat");
			clipPlaneSimpleDebugMaterial = global::VRMod.VRMod.VRAssetBundle.LoadAsset<Material>("LIV_ClipPlaneSimpleDebugMat");
			clipPlaneComplexMaterial = global::VRMod.VRMod.VRAssetBundle.LoadAsset<Material>("LIV_ClipPlaneComplexMat");
			clipPlaneComplexDebugMaterial = global::VRMod.VRMod.VRAssetBundle.LoadAsset<Material>("LIV_ClipPlaneComplexDebugMat");
			writeOpaqueToAlphaMaterial = global::VRMod.VRMod.VRAssetBundle.LoadAsset<Material>("LIV_WriteOpaqueToAlphaMat");
			combineAlphaMaterial = global::VRMod.VRMod.VRAssetBundle.LoadAsset<Material>("LIV_CombineAlphaMat");
			writeMaterial = global::VRMod.VRMod.VRAssetBundle.LoadAsset<Material>("LIV_WriteMat");
			forceForwardRenderingMaterial = global::VRMod.VRMod.VRAssetBundle.LoadAsset<Material>("LIV_ForceForwardRenderingMat");
		}

		public static void StartRendering()
		{
			Shader.EnableKeyword("LIV_MR");
		}

		public static void StopRendering()
		{
			Shader.DisableKeyword("LIV_MR");
		}

		public static void StartForegroundRendering()
		{
			Shader.EnableKeyword("LIV_MR_FOREGROUND");
		}

		public static void StopForegroundRendering()
		{
			Shader.DisableKeyword("LIV_MR_FOREGROUND");
		}

		public static void StartBackgroundRendering()
		{
			Shader.EnableKeyword("LIV_MR_BACKGROUND");
		}

		public static void StopBackgroundRendering()
		{
			Shader.DisableKeyword("LIV_MR_BACKGROUND");
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct SDKConstants
	{
		public const string SDK_ID = "UT4QDBPGHQZHTDVOSRUHN1PZZCM187WV";

		public const string SDK_VERSION = "1.5.4";

		public const string ENGINE_NAME = "unity";
	}
	public enum PRIORITY : sbyte
	{
		NONE = 0,
		GAME = 63
	}
	[Flags]
	public enum FEATURES : ulong
	{
		NONE = 0uL,
		BACKGROUND_RENDER = 1uL,
		FOREGROUND_RENDER = 2uL,
		COMPLEX_CLIP_PLANE = 4uL,
		BACKGROUND_DEPTH_RENDER = 8uL,
		OVERRIDE_POST_PROCESSING = 0x10uL,
		FIX_FOREGROUND_ALPHA = 0x20uL,
		GROUND_CLIP_PLANE = 0x40uL,
		RELEASE_CONTROL = 0x8000uL,
		OPTIMIZED_RENDER = 0x10000000uL,
		INTERLACED_RENDER = 0x20000000uL,
		DEBUG_CLIP_PLANE = 0x1000000000000uL
	}
	public enum TEXTURE_ID : uint
	{
		UNDEFINED = 0u,
		BACKGROUND_COLOR_BUFFER_ID = 10u,
		FOREGROUND_COLOR_BUFFER_ID = 20u,
		OPTIMIZED_COLOR_BUFFER_ID = 30u
	}
	public enum TEXTURE_TYPE : uint
	{
		UNDEFINED,
		COLOR_BUFFER
	}
	public enum TEXTURE_FORMAT : uint
	{
		UNDEFINED = 0u,
		ARGB32 = 10u
	}
	public enum TEXTURE_DEVICE : uint
	{
		UNDEFINED,
		RAW,
		DIRECTX,
		OPENGL,
		VULKAN,
		METAL
	}
	public enum TEXTURE_COLOR_SPACE : uint
	{
		UNDEFINED,
		LINEAR,
		SRGB
	}
	public enum RENDERING_PIPELINE : uint
	{
		UNDEFINED,
		FORWARD,
		DEFERRED,
		VERTEX_LIT,
		UNIVERSAL,
		HIGH_DEFINITION
	}
	public struct SDKResolution
	{
		public int width;

		public int height;

		public static SDKResolution zero => new SDKResolution
		{
			width = 0,
			height = 0
		};

		public override string ToString()
		{
			return $"SDKResolution:\nwidth: {width}\nheight: {height}";
		}
	}
	public struct SDKVector3
	{
		public float x;

		public float y;

		public float z;

		public static SDKVector3 zero => new SDKVector3
		{
			x = 0f,
			y = 0f,
			z = 0f
		};

		public static SDKVector3 one => new SDKVector3
		{
			x = 1f,
			y = 1f,
			z = 1f
		};

		public static SDKVector3 forward => new SDKVector3
		{
			x = 0f,
			y = 0f,
			z = 1f
		};

		public static SDKVector3 up => new SDKVector3
		{
			x = 0f,
			y = 1f,
			z = 0f
		};

		public static SDKVector3 right => new SDKVector3
		{
			x = 1f,
			y = 0f,
			z = 0f
		};

		public static implicit operator Vector3(SDKVector3 v)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(v.x, v.y, v.z);
		}

		public static implicit operator SDKVector3(Vector3 v)
		{
			//IL_000a: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			return new SDKVector3
			{
				x = v.x,
				y = v.y,
				z = v.z
			};
		}

		public static SDKVector3 operator +(SDKVector3 lhs, SDKVector3 rhs)
		{
			SDKVector3 result = default(SDKVector3);
			result.x = lhs.x + rhs.x;
			result.y = lhs.y + rhs.y;
			result.z = lhs.z + rhs.z;
			return result;
		}

		public static SDKVector3 operator -(SDKVector3 lhs, SDKVector3 rhs)
		{
			SDKVector3 result = default(SDKVector3);
			result.x = lhs.x - rhs.x;
			result.y = lhs.y - rhs.y;
			result.z = lhs.z - rhs.z;
			return result;
		}

		public static SDKVector3 operator *(SDKVector3 lhs, SDKVector3 rhs)
		{
			SDKVector3 result = default(SDKVector3);
			result.x = lhs.x * rhs.x;
			result.y = lhs.y * rhs.y;
			result.z = lhs.z * rhs.z;
			return result;
		}

		public static SDKVector3 operator *(SDKVector3 lhs, float rhs)
		{
			SDKVector3 result = default(SDKVector3);
			result.x = lhs.x * rhs;
			result.y = lhs.y * rhs;
			result.z = lhs.z * rhs;
			return result;
		}

		public override string ToString()
		{
			return $"SDKVector3:\nx: {x}\ny: {y}\nz: {z}";
		}
	}
	public struct SDKQuaternion
	{
		public float x;

		public float y;

		public float z;

		public float w;

		public static SDKQuaternion identity => new SDKQuaternion
		{
			x = 0f,
			y = 0f,
			z = 0f,
			w = 1f
		};

		public static implicit operator Quaternion(SDKQuaternion v)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return new Quaternion(v.x, v.y, v.z, v.w);
		}

		public static implicit operator SDKQuaternion(Quaternion v)
		{
			//IL_000a: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			return new SDKQuaternion
			{
				x = v.x,
				y = v.y,
				z = v.z,
				w = v.w
			};
		}

		public static SDKQuaternion Euler(float pitch, float yaw, float roll)
		{
			float num = roll * 0.5f;
			float num2 = Mathf.Sin(num);
			float num3 = Mathf.Cos(num);
			float num4 = pitch * 0.5f;
			float num5 = Mathf.Sin(num4);
			float num6 = Mathf.Cos(num4);
			float num7 = yaw * 0.5f;
			float num8 = Mathf.Sin(num7);
			float num9 = Mathf.Cos(num7);
			float num10 = num9 * num6 * num3 + num8 * num5 * num2;
			float num11 = num9 * num5 * num3 + num8 * num6 * num2;
			float num12 = num8 * num6 * num3 - num9 * num5 * num2;
			float num13 = num9 * num6 * num2 - num8 * num5 * num3;
			return new SDKQuaternion
			{
				x = num11,
				y = num12,
				z = num13,
				w = num10
			};
		}

		public static SDKQuaternion operator *(SDKQuaternion lhs, SDKQuaternion rhs)
		{
			float num = lhs.w * rhs.x + lhs.x * rhs.w + lhs.y * rhs.z - lhs.z * rhs.y;
			float num2 = lhs.w * rhs.y + lhs.y * rhs.w + lhs.z * rhs.x - lhs.x * rhs.z;
			float num3 = lhs.w * rhs.z + lhs.z * rhs.w + lhs.x * rhs.y - lhs.y * rhs.x;
			float num4 = lhs.w * rhs.w - lhs.x * rhs.x - lhs.y * rhs.y - lhs.z * rhs.z;
			return new SDKQuaternion
			{
				x = num,
				y = num2,
				z = num3,
				w = num4
			};
		}

		public static SDKVector3 operator *(SDKQuaternion lhs, SDKVector3 rhs)
		{
			float num = lhs.x * 2f;
			float num2 = lhs.y * 2f;
			float num3 = lhs.z * 2f;
			float num4 = lhs.x * num;
			float num5 = lhs.y * num2;
			float num6 = lhs.z * num3;
			float num7 = lhs.x * num2;
			float num8 = lhs.x * num3;
			float num9 = lhs.y * num3;
			float num10 = lhs.w * num;
			float num11 = lhs.w * num2;
			float num12 = lhs.w * num3;
			SDKVector3 result = default(SDKVector3);
			result.x = (1f - (num5 + num6)) * rhs.x + (num7 - num12) * rhs.y + (num8 + num11) * rhs.z;
			result.y = (num7 + num12) * rhs.x + (1f - (num4 + num6)) * rhs.y + (num9 - num10) * rhs.z;
			result.z = (num8 - num11) * rhs.x + (num9 + num10) * rhs.y + (1f - (num4 + num5)) * rhs.z;
			return result;
		}

		public override string ToString()
		{
			return $"SDKQuaternion:\nx: {x}\ny: {y}\nz: {z}\nw: {w}";
		}
	}
	public struct SDKMatrix4x4
	{
		public float m00;

		public float m01;

		public float m02;

		public float m03;

		public float m10;

		public float m11;

		public float m12;

		public float m13;

		public float m20;

		public float m21;

		public float m22;

		public float m23;

		public float m30;

		public float m31;

		public float m32;

		public float m33;

		public static SDKMatrix4x4 identity => new SDKMatrix4x4
		{
			m00 = 1f,
			m01 = 0f,
			m02 = 0f,
			m03 = 0f,
			m10 = 0f,
			m11 = 1f,
			m12 = 0f,
			m13 = 0f,
			m20 = 0f,
			m21 = 0f,
			m22 = 1f,
			m23 = 0f,
			m30 = 0f,
			m31 = 0f,
			m32 = 0f,
			m33 = 1f
		};

		public static implicit operator Matrix4x4(SDKMatrix4x4 v)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			return new Matrix4x4
			{
				m00 = v.m00,
				m01 = v.m01,
				m02 = v.m02,
				m03 = v.m03,
				m10 = v.m10,
				m11 = v.m11,
				m12 = v.m12,
				m13 = v.m13,
				m20 = v.m20,
				m21 = v.m21,
				m22 = v.m22,
				m23 = v.m23,
				m30 = v.m30,
				m31 = v.m31,
				m32 = v.m32,
				m33 = v.m33
			};
		}

		public static implicit operator SDKMatrix4x4(Matrix4x4 v)
		{
			//IL_000a: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_0058: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			return new SDKMatrix4x4
			{
				m00 = v.m00,
				m01 = v.m01,
				m02 = v.m02,
				m03 = v.m03,
				m10 = v.m10,
				m11 = v.m11,
				m12 = v.m12,
				m13 = v.m13,
				m20 = v.m20,
				m21 = v.m21,
				m22 = v.m22,
				m23 = v.m23,
				m30 = v.m30,
				m31 = v.m31,
				m32 = v.m32,
				m33 = v.m33
			};
		}

		public static SDKMatrix4x4 Perspective(float vFov, float aspect, float zNear, float zFar)
		{
			float num = vFov * ((float)Math.PI / 180f);
			float num2 = 2f * Mathf.Atan(Mathf.Tan(num * 0.5f) * aspect);
			float num3 = 1f / Mathf.Tan(num2 * 0.5f);
			float num4 = 1f / Mathf.Tan(num * 0.5f);
			float num5 = (zFar + zNear) / (zNear - zFar);
			float num6 = 2f * (zFar * zNear) / (zNear - zFar);
			return new SDKMatrix4x4
			{
				m00 = num3,
				m01 = 0f,
				m02 = 0f,
				m03 = 0f,
				m10 = 0f,
				m11 = num4,
				m12 = 0f,
				m13 = 0f,
				m20 = 0f,
				m21 = 0f,
				m22 = num5,
				m23 = num6,
				m30 = 0f,
				m31 = 0f,
				m32 = -1f,
				m33 = 0f
			};
		}

		public static SDKMatrix4x4 operator *(SDKMatrix4x4 lhs, SDKMatrix4x4 rhs)
		{
			SDKMatrix4x4 result = identity;
			result.m00 = lhs.m00 * rhs.m00 + lhs.m01 * rhs.m10 + lhs.m02 * rhs.m20 + lhs.m03 * rhs.m30;
			result.m01 = lhs.m00 * rhs.m01 + lhs.m01 * rhs.m11 + lhs.m02 * rhs.m21 + lhs.m03 * rhs.m31;
			result.m02 = lhs.m00 * rhs.m02 + lhs.m01 * rhs.m12 + lhs.m02 * rhs.m22 + lhs.m03 * rhs.m32;
			result.m03 = lhs.m00 * rhs.m03 + lhs.m01 * rhs.m13 + lhs.m02 * rhs.m23 + lhs.m03 * rhs.m33;
			result.m10 = lhs.m10 * rhs.m00 + lhs.m11 * rhs.m10 + lhs.m12 * rhs.m20 + lhs.m13 * rhs.m30;
			result.m11 = lhs.m10 * rhs.m01 + lhs.m11 * rhs.m11 + lhs.m12 * rhs.m21 + lhs.m13 * rhs.m31;
			result.m12 = lhs.m10 * rhs.m02 + lhs.m11 * rhs.m12 + lhs.m12 * rhs.m22 + lhs.m13 * rhs.m32;
			result.m13 = lhs.m10 * rhs.m03 + lhs.m11 * rhs.m13 + lhs.m12 * rhs.m23 + lhs.m13 * rhs.m33;
			result.m20 = lhs.m20 * rhs.m00 + lhs.m21 * rhs.m10 + lhs.m22 * rhs.m20 + lhs.m23 * rhs.m30;
			result.m21 = lhs.m20 * rhs.m01 + lhs.m21 * rhs.m11 + lhs.m22 * rhs.m21 + lhs.m23 * rhs.m31;
			result.m22 = lhs.m20 * rhs.m02 + lhs.m21 * rhs.m12 + lhs.m22 * rhs.m22 + lhs.m23 * rhs.m32;
			result.m23 = lhs.m20 * rhs.m03 + lhs.m21 * rhs.m13 + lhs.m22 * rhs.m23 + lhs.m23 * rhs.m33;
			result.m30 = lhs.m30 * rhs.m00 + lhs.m31 * rhs.m10 + lhs.m32 * rhs.m20 + lhs.m33 * rhs.m30;
			result.m31 = lhs.m30 * rhs.m01 + lhs.m31 * rhs.m11 + lhs.m32 * rhs.m21 + lhs.m33 * rhs.m31;
			result.m32 = lhs.m30 * rhs.m02 + lhs.m31 * rhs.m12 + lhs.m32 * rhs.m22 + lhs.m33 * rhs.m32;
			result.m33 = lhs.m30 * rhs.m03 + lhs.m31 * rhs.m13 + lhs.m32 * rhs.m23 + lhs.m33 * rhs.m33;
			return result;
		}

		public static SDKVector3 operator *(SDKMatrix4x4 lhs, SDKVector3 rhs)
		{
			SDKVector3 result = default(SDKVector3);
			result.x = lhs.m00 * rhs.x + lhs.m01 * rhs.y + lhs.m02 * rhs.z;
			result.y = lhs.m10 * rhs.x + lhs.m11 * rhs.y + lhs.m12 * rhs.z;
			result.z = lhs.m20 * rhs.x + lhs.m21 * rhs.y + lhs.m22 * rhs.z;
			return result;
		}

		public static SDKMatrix4x4 Translate(SDKVector3 value)
		{
			return new SDKMatrix4x4
			{
				m00 = 1f,
				m01 = 0f,
				m02 = 0f,
				m03 = value.x,
				m10 = 0f,
				m11 = 1f,
				m12 = 0f,
				m13 = value.y,
				m20 = 0f,
				m21 = 0f,
				m22 = 1f,
				m23 = value.z,
				m30 = 0f,
				m31 = 0f,
				m32 = 0f,
				m33 = 1f
			};
		}

		public static SDKMatrix4x4 Rotate(SDKQuaternion value)
		{
			float x = value.x;
			float y = value.y;
			float z = value.z;
			float w = value.w;
			return new SDKMatrix4x4
			{
				m00 = 1f - 2f * y * y - 2f * z * z,
				m01 = 2f * x * y - 2f * z * w,
				m02 = 2f * x * z + 2f * y * w,
				m03 = 0f,
				m10 = 2f * x * y + 2f * z * w,
				m11 = 1f - 2f * x * x - 2f * z * z,
				m12 = 2f * y * z - 2f * x * w,
				m13 = 0f,
				m20 = 2f * x * z - 2f * y * w,
				m21 = 2f * y * z + 2f * x * w,
				m22 = 1f - 2f * x * x - 2f * y * y,
				m23 = 0f,
				m30 = 0f,
				m31 = 0f,
				m32 = 0f,
				m33 = 1f
			};
		}

		public static SDKMatrix4x4 Scale(SDKVector3 value)
		{
			return new SDKMatrix4x4
			{
				m00 = value.x,
				m01 = 0f,
				m02 = 0f,
				m03 = 0f,
				m10 = 0f,
				m11 = value.y,
				m12 = 0f,
				m13 = 0f,
				m20 = 0f,
				m21 = 0f,
				m22 = value.z,
				m23 = 0f,
				m30 = 0f,
				m31 = 0f,
				m32 = 0f,
				m33 = 1f
			};
		}

		public static SDKMatrix4x4 TRS(SDKVector3 translation, SDKQuaternion rotation, SDKVector3 scale)
		{
			return Translate(translation) * Rotate(rotation) * Scale(scale);
		}

		public override string ToString()
		{
			return $"Matrix4x4:\n{m00} {m01} {m02} {m03}\n{m10} {m11} {m12} {m13}\n{m20} {m21} {m22} {m23}\n{m30} {m31} {m32} {m33}";
		}
	}
	public struct SDKPlane
	{
		public float distance;

		public SDKVector3 normal;

		public static SDKPlane empty => new SDKPlane
		{
			distance = 0f,
			normal = SDKVector3.up
		};

		public static implicit operator SDKPlane(Plane v)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			return new SDKPlane
			{
				distance = ((Plane)(ref v)).distance,
				normal = ((Plane)(ref v)).normal
			};
		}

		public override string ToString()
		{
			return $"SDKPlane:\n{distance} {normal}";
		}
	}
	public struct SDKPriority
	{
		public sbyte pose;

		public sbyte clipPlane;

		public sbyte stage;

		public sbyte resolution;

		public sbyte feature;

		public sbyte nearFarAdjustment;

		public sbyte groundPlane;

		public sbyte reserved2;

		public static SDKPriority empty => new SDKPriority
		{
			pose = -63,
			clipPlane = -63,
			stage = -63,
			resolution = -63,
			feature = -63,
			nearFarAdjustment = 63,
			groundPlane = -63,
			reserved2 = -63
		};

		public override string ToString()
		{
			return $"Priority:\npose: {pose}, clipPlane: {clipPlane}, stage: {stage}, resolution: {resolution}, feature: {feature}, nearFarAdjustment: {nearFarAdjustment}, groundPlane: {groundPlane}";
		}
	}
	public struct SDKApplicationOutput
	{
		public FEATURES supportedFeatures;

		public string engineName;

		public string engineVersion;

		public string applicationName;

		public string applicationVersion;

		public string xrDeviceName;

		public string graphicsAPI;

		public string sdkID;

		public string sdkVersion;

		public static SDKApplicationOutput empty => new SDKApplicationOutput
		{
			supportedFeatures = FEATURES.NONE,
			engineName = string.Empty,
			engineVersion = string.Empty,
			applicationName = string.Empty,
			applicationVersion = string.Empty,
			xrDeviceName = string.Empty,
			graphicsAPI = string.Empty,
			sdkID = "UT4QDBPGHQZHTDVOSRUHN1PZZCM187WV",
			sdkVersion = string.Empty
		};

		public override string ToString()
		{
			return $"SDKApplicationOutput:\nsupportedFeatures: {supportedFeatures}\nengineName: {engineName}\nengineVersion: {engineVersion}\napplicationName: {applicationName}\napplicationVersion: {applicationVersion}\nxrDeviceName: {xrDeviceName}\ngraphicsAPI: {graphicsAPI}\nsdkID: {sdkID}\nsdkVersion: {sdkVersion}";
		}
	}
	public struct SDKInputFrame
	{
		public SDKPose pose;

		public SDKClipPlane clipPlane;

		public SDKTransform stageTransform;

		public FEATURES features;

		public SDKClipPlane groundClipPlane;

		public ulong frameid;

		public ulong referenceframe;

		public SDKPriority priority;

		public static SDKInputFrame empty => new SDKInputFrame
		{
			pose = SDKPose.empty,
			clipPlane = SDKClipPlane.empty,
			stageTransform = SDKTransform.empty,
			features = FEATURES.NONE,
			groundClipPlane = SDKClipPlane.empty,
			frameid = 0uL,
			referenceframe = 0uL,
			priority = SDKPriority.empty
		};

		public void ReleaseControl()
		{
			priority = SDKPriority.empty;
		}

		public void ObtainControl()
		{
			priority = SDKPriority.empty;
			priority.pose = 63;
		}

		public override string ToString()
		{
			return $"SDKInputFrame:\npose: {pose}\nclipPlane: {clipPlane}\nstageTransform: {stageTransform}\nfeatures: {features}\ngroundClipPlane: {groundClipPlane}\nframeid: {frameid}\nreferenceframe: {referenceframe}\npriority: {priority:X4}";
		}
	}
	public struct SDKOutputFrame
	{
		public RENDERING_PIPELINE renderingPipeline;

		public SDKTrackedSpace trackedSpace;

		public static SDKOutputFrame empty => new SDKOutputFrame
		{
			renderingPipeline = RENDERING_PIPELINE.UNDEFINED,
			trackedSpace = SDKTrackedSpace.empty
		};

		public override string ToString()
		{
			return $"SDKOutputFrame:\nrenderingPipeline: {renderingPipeline}\ntrackedSpace: {trackedSpace}";
		}
	}
	public struct SDKTrackedSpace
	{
		public SDKVector3 trackedSpaceWorldPosition;

		public SDKQuaternion trackedSpaceWorldRotation;

		public SDKVector3 trackedSpaceLocalScale;

		public SDKMatrix4x4 trackedSpaceLocalToWorldMatrix;

		public SDKMatrix4x4 trackedSpaceWorldToLocalMatrix;

		public static SDKTrackedSpace empty => new SDKTrackedSpace
		{
			trackedSpaceWorldPosition = SDKVector3.zero,
			trackedSpaceWorldRotation = SDKQuaternion.identity,
			trackedSpaceLocalScale = SDKVector3.zero,
			trackedSpaceLocalToWorldMatrix = SDKMatrix4x4.identity,
			trackedSpaceWorldToLocalMatrix = SDKMatrix4x4.identity
		};

		public override string ToString()
		{
			return $"SDKTrackedSpace:\ntrackedSpaceWorldPosition: {trackedSpaceWorldPosition}\ntrackedSpaceWorldRotation: {trackedSpaceWorldRotation}\ntrackedSpaceLocalScale: {trackedSpaceLocalScale}\ntrackedSpaceLocalToWorldMatrix: {trackedSpaceLocalToWorldMatrix}\ntrackedSpaceWorldToLocalMatrix: {trackedSpaceWorldToLocalMatrix}";
		}
	}
	public struct SDKTexture
	{
		public TEXTURE_ID id;

		public IntPtr texturePtr;

		public IntPtr SharedHandle;

		public TEXTURE_DEVICE device;

		public int dummy;

		public TEXTURE_TYPE type;

		public TEXTURE_FORMAT format;

		public TEXTURE_COLOR_SPACE colorSpace;

		public int width;

		public int height;

		public static SDKTexture empty => new SDKTexture
		{
			id = TEXTURE_ID.UNDEFINED,
			texturePtr = IntPtr.Zero,
			SharedHandle = IntPtr.Zero,
			device = TEXTURE_DEVICE.UNDEFINED,
			dummy = 0,
			type = TEXTURE_TYPE.UNDEFINED,
			format = TEXTURE_FORMAT.UNDEFINED,
			colorSpace = TEXTURE_COLOR_SPACE.UNDEFINED,
			width = 0,
			height = 0
		};

		public override string ToString()
		{
			return $"SDKTexture:\nid: {id}\ntexturePtr: {texturePtr}\nSharedHandle: {SharedHandle}\ndevice: {device}\ndummy: {dummy}\ntype: {type}\nformat: {format}\ncolorSpace: {colorSpace}\nwidth: {width}\nheight: {height}";
		}
	}
	public struct SDKTransform
	{
		public SDKVector3 localPosition;

		public SDKQuaternion localRotation;

		public SDKVector3 localScale;

		public static SDKTransform empty => new SDKTransform
		{
			localPosition = SDKVector3.zero,
			localRotation = SDKQuaternion.identity,
			localScale = SDKVector3.one
		};

		public override string ToString()
		{
			return $"SDKTransform:\nlocalPosition: {localPosition}\nlocalRotation: {localRotation}\nlocalScale: {localScale}";
		}
	}
	public struct SDKClipPlane
	{
		public SDKMatrix4x4 transform;

		public int width;

		public int height;

		public float tesselation;

		public static SDKClipPlane empty => new SDKClipPlane
		{
			transform = SDKMatrix4x4.identity,
			width = 0,
			height = 0,
			tesselation = 0f
		};

		public override string ToString()
		{
			return $"SDKClipPlane:\ntransform: {transform}\nwidth: {width}\nheight: {height}\ntesselation: {tesselation}";
		}
	}
	public struct SDKControllerState
	{
		public SDKVector3 hmdposition;

		public SDKQuaternion hmdrotation;

		public SDKVector3 calibrationcameraposition;

		public SDKQuaternion calibrationcamerarotation;

		public SDKVector3 cameraposition;

		public SDKQuaternion camerarotation;

		public SDKVector3 leftposition;

		public SDKQuaternion leftrotation;

		public SDKVector3 rightposition;

		public SDKQuaternion rightrotation;

		public static SDKControllerState empty => new SDKControllerState
		{
			hmdposition = SDKVector3.zero,
			hmdrotation = SDKQuaternion.identity,
			calibrationcameraposition = SDKVector3.zero,
			calibrationcamerarotation = SDKQuaternion.identity,
			cameraposition = SDKVector3.zero,
			camerarotation = SDKQuaternion.identity,
			leftposition = SDKVector3.zero,
			leftrotation = SDKQuaternion.identity,
			rightposition = SDKVector3.zero,
			rightrotation = SDKQuaternion.identity
		};

		public override string ToString()
		{
			return $"SDKControllerState:\nhmdposition: {hmdposition}\nhmdrotation: {hmdrotation}\ncalibrationcameraposition: {calibrationcameraposition}\ncalibrationcamerarotation: {calibrationcamerarotation}\ncameraposition: {cameraposition}\ncamerarotation: {camerarotation}\nleftposition: {leftposition}\nleftrotation: {leftrotation}\nrightposition: {rightposition}\nrightrotation: {rightrotation}";
		}
	}
	public struct SDKPose
	{
		public SDKMatrix4x4 projectionMatrix;

		public SDKVector3 localPosition;

		public SDKQuaternion localRotation;

		public float verticalFieldOfView;

		public float nearClipPlane;

		public float farClipPlane;

		public int unused0;

		public int unused1;

		public static SDKPose empty => new SDKPose
		{
			projectionMatrix = SDKMatrix4x4.Perspective(90f, 1f, 0.01f, 1000f),
			localPosition = SDKVector3.zero,
			localRotation = SDKQuaternion.identity,
			verticalFieldOfView = 90f,
			nearClipPlane = 0.01f,
			farClipPlane = 1000f
		};

		public override string ToString()
		{
			return $"SDKPose:\nprojectionMatrix: {projectionMatrix}\nlocalPosition: {localPosition}\nlocalRotation: {localRotation}\nverticalFieldOfView: {verticalFieldOfView}\nnearClipPlane: {nearClipPlane}\nfarClipPlane: {farClipPlane}";
		}
	}
	public static class SDKUtils
	{
		public static TEXTURE_COLOR_SPACE GetDefaultColorSpace
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Invalid comparison between Unknown and I4
				ColorSpace activeColorSpace = QualitySettings.activeColorSpace;
				if ((int)activeColorSpace != 0)
				{
					if ((int)activeColorSpace == 1)
					{
						return TEXTURE_COLOR_SPACE.LINEAR;
					}
					return TEXTURE_COLOR_SPACE.UNDEFINED;
				}
				return TEXTURE_COLOR_SPACE.SRGB;
			}
		}

		public static void CreateClipPlane(Mesh mesh, int resX, int resY, bool useQuads, float skirtLength)
		{
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			int num = (resX + 1) * (resY + 1);
			int num2 = (useQuads ? (resX * resY * 4) : (resX * resY * 2 * 3));
			Vector3[] array = (Vector3[])(object)new Vector3[num];
			Vector2[] array2 = (Vector2[])(object)new Vector2[num];
			int[] array3 = new int[num2];
			float num3 = 0.5f;
			float num4 = 0.5f;
			int num5 = resX + 1;
			int num6 = resY + 1;
			for (int i = 0; i < num6; i++)
			{
				for (int j = 0; j < num5; j++)
				{
					int num7 = i * num5 + j;
					float num8 = (float)j / (float)resX;
					float num9 = (float)i / (float)resY;
					float num10 = ((j == 0 || j == resX) ? skirtLength : 1f);
					float num11 = ((i == 0 || i == resY) ? skirtLength : 1f);
					array[num7] = Vector2.op_Implicit(new Vector2((0f - num3 + num8) * num10, (0f - num4 + num9) * num11));
					array2[num7] = new Vector2(Mathf.InverseLerp(1f, (float)(resX - 1), (float)j), Mathf.InverseLerp(1f, (float)(resY - 1), (float)i));
				}
			}
			mesh.Clear();
			mesh.vertices = array;
			mesh.uv = array2;
			mesh.bounds = new Bounds(Vector3.zero, Vector3.one * float.MaxValue);
			int num12 = resX * resY;
			int num13 = 0;
			int num14 = 0;
			if (useQuads)
			{
				for (int k = 0; k < num12; k++)
				{
					num13 = k / resX * num5 + k % resX;
					array3[num14++] = num13 + 1;
					array3[num14++] = num13;
					array3[num14++] = num13 + 1 + resX;
					array3[num14++] = num13 + 2 + resX;
				}
				mesh.SetIndices(array3, (MeshTopology)2, 0);
				return;
			}
			for (int l = 0; l < num12; l++)
			{
				num13 = l / resX * num5 + l % resX;
				array3[num14++] = num13 + 2 + resX;
				array3[num14++] = num13 + 1;
				array3[num14++] = num13;
				array3[num14++] = num13 + 1 + resX;
				array3[num14++] = num13 + 2 + resX;
				array3[num14++] = num13;
			}
			mesh.SetIndices(array3, (MeshTopology)0, 0);
		}

		public static RenderTextureReadWrite GetReadWriteFromColorSpace(TEXTURE_COLOR_SPACE colorSpace)
		{
			return (RenderTextureReadWrite)(colorSpace switch
			{
				TEXTURE_COLOR_SPACE.LINEAR => 1, 
				TEXTURE_COLOR_SPACE.SRGB => 2, 
				_ => 0, 
			});
		}

		public static TEXTURE_COLOR_SPACE GetColorSpace(RenderTexture renderTexture)
		{
			if ((Object)(object)renderTexture == (Object)null)
			{
				return TEXTURE_COLOR_SPACE.UNDEFINED;
			}
			if (renderTexture.sRGB)
			{
				return TEXTURE_COLOR_SPACE.SRGB;
			}
			return TEXTURE_COLOR_SPACE.LINEAR;
		}

		public static RENDERING_PIPELINE GetRenderingPipeline(RenderingPath renderingPath)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected I4, but got Unknown
			return (int)renderingPath switch
			{
				2 => RENDERING_PIPELINE.DEFERRED, 
				3 => RENDERING_PIPELINE.DEFERRED, 
				1 => RENDERING_PIPELINE.FORWARD, 
				0 => RENDERING_PIPELINE.VERTEX_LIT, 
				_ => RENDERING_PIPELINE.UNDEFINED, 
			};
		}

		public static TEXTURE_DEVICE GetDevice()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_000a: 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_002b: Expected I4, but got Unknown
			GraphicsDeviceType graphicsDeviceType = SystemInfo.graphicsDeviceType;
			if ((int)graphicsDeviceType != 2)
			{
				switch (graphicsDeviceType - 16)
				{
				case 2:
					break;
				case 5:
					return TEXTURE_DEVICE.VULKAN;
				case 0:
					return TEXTURE_DEVICE.METAL;
				case 1:
					return TEXTURE_DEVICE.OPENGL;
				default:
					return TEXTURE_DEVICE.UNDEFINED;
				}
			}
			return TEXTURE_DEVICE.DIRECTX;
		}

		public static bool ContainsFlag(ulong flags, ulong flag)
		{
			return (flags & flag) != 0;
		}

		public static ulong SetFlag(ulong flags, ulong flag, bool enabled)
		{
			if (enabled)
			{
				return flags | flag;
			}
			return flags & ~flag;
		}

		public static void GetCameraPositionAndRotation(SDKPose pose, Matrix4x4 originLocalToWorldMatrix, out Vector3 position, out Quaternion rotation)
		{
			//IL_0009: 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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			position = ((Matrix4x4)(ref originLocalToWorldMatrix)).MultiplyPoint((Vector3)pose.localPosition);
			rotation = RotateQuaternionByMatrix(originLocalToWorldMatrix, pose.localRotation);
		}

		public static void CleanCameraBehaviours(Camera camera, string[] excludeBehaviours)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			foreach (Transform item in ((Component)camera).transform)
			{
				Object.Destroy((Object)(object)((Component)item).gameObject);
			}
			if (excludeBehaviours != null)
			{
				for (int i = 0; i < excludeBehaviours.Length; i++)
				{
					Object.Destroy((Object)(object)((Component)camera).GetComponent(excludeBehaviours[i]));
				}
			}
		}

		public static void SetCamera(Camera camera, Transform cameraTransform, SDKInputFrame inputFrame, Matrix4x4 originLocalToWorldMatrix, int layerMask)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = Vector3.zero;
			Quaternion rotation = Quaternion.identity;
			float verticalFieldOfView = inputFrame.pose.verticalFieldOfView;
			float nearClipPlane = inputFrame.pose.nearClipPlane;
			float farClipPlane = inputFrame.pose.farClipPlane;
			Matrix4x4 projectionMatrix = inputFrame.pose.projectionMatrix;
			GetCameraPositionAndRotation(inputFrame.pose, originLocalToWorldMatrix, out position, out rotation);
			cameraTransform.position = position;
			cameraTransform.rotation = rotation;
			camera.fieldOfView = verticalFieldOfView;
			camera.nearClipPlane = nearClipPlane;
			camera.farClipPlane = farClipPlane;
			camera.projectionMatrix = projectionMatrix;
			camera.cullingMask = layerMask;
		}

		public static Quaternion RotateQuaternionByMatrix(Matrix4x4 matrix, Quaternion rotation)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			return Quaternion.LookRotation(((Matrix4x4)(ref matrix)).MultiplyVector(Vector3.forward), ((Matrix4x4)(ref matrix)).MultiplyVector(Vector3.up)) * rotation;
		}

		public static SDKTrackedSpace GetTrackedSpace(Transform transform)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)transform == (Object)null)
			{
				return SDKTrackedSpace.empty;
			}
			return new SDKTrackedSpace
			{
				trackedSpaceWorldPosition = transform.position,
				trackedSpaceWorldRotation = transform.rotation,
				trackedSpaceLocalScale = transform.localScale,
				trackedSpaceLocalToWorldMatrix = transform.localToWorldMatrix,
				trackedSpaceWorldToLocalMatrix = transform.worldToLocalMatrix
			};
		}

		public static bool DestroyObject<T>(ref T reference) where T : Object
		{
			if ((Object)(object)reference == (Object)null)
			{
				return false;
			}
			Object.Destroy((Object)(object)reference);
			reference = default(T);
			return true;
		}

		public static bool DisposeObject<T>(ref T reference) where T : IDisposable
		{
			if (reference == null)
			{
				return false;
			}
			reference.Dispose();
			reference = default(T);
			return true;
		}

		public static bool CreateTexture(ref RenderTexture renderTexture, int width, int height, int depth, RenderTextureFormat format)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			DestroyTexture(ref renderTexture);
			if (width <= 0 || height <= 0)
			{
				Debug.LogError((object)"LIV: Unable to create render texture. Texture dimension must be higher than zero.");
				return false;
			}
			renderTexture = new RenderTexture(width, height, depth, format)
			{
				antiAliasing = 1,
				wrapMode = (TextureWrapMode)1,
				useMipMap = false,
				anisoLevel = 0
			};
			if (!renderTexture.Create())
			{
				Debug.LogError((object)"LIV: Unable to create render texture.");
				return false;
			}
			return true;
		}

		public static void DestroyTexture(ref RenderTexture _renderTexture)
		{
			if (!((Object)(object)_renderTexture == (Object)null))
			{
				if (_renderTexture.IsCreated())
				{
					_renderTexture.Release();
				}
				_renderTexture = null;
			}
		}

		public static void ApplyUserSpaceTransform(SDKRender render)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)render.stageTransform == (Object)null))
			{
				render.stageTransform.localPosition = render.inputFrame.stageTransform.localPosition;
				render.stageTransform.localRotation = render.inputFrame.stageTransform.localRotation;
				render.stageTransform.localScale = render.inputFrame.stageTransform.localScale;
			}
		}

		public static void CreateBridgeOutputFrame(SDKRender render)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			RENDERING_PIPELINE renderingPipeline = RENDERING_PIPELINE.UNDEFINED;
			if ((Object)(object)render.cameraInstance != (Object)null)
			{
				renderingPipeline = GetRenderingPipeline(render.cameraInstance.actualRenderingPath);
			}
			SDKBridge.CreateFrame(new SDKOutputFrame
			{
				renderingPipeline = renderingPipeline,
				trackedSpace = GetTrackedSpace(((Object)(object)render.stageTransform == (Object)null) ? render.stage : render.stageTransform)
			});
		}

		public static bool FeatureEnabled(FEATURES features, FEATURES feature)
		{
			return ContainsFlag((ulong)features, (ulong)feature);
		}

		public static void DisableStandardAssets(Camera cameraInstance, ref MonoBehaviour[] behaviours, ref bool[] wasBehaviourEnabled)
		{
			behaviours = null;
			wasBehaviourEnabled = null;
			behaviours = ((Component)cameraInstance).gameObject.GetComponents<MonoBehaviour>();
			wasBehaviourEnabled = new bool[behaviours.Length];
			for (int i = 0; i < behaviours.Length; i++)
			{
				MonoBehaviour val = behaviours[i];
				if (((Behaviour)val).enabled && ((object)val).GetType().ToString().StartsWith("UnityStandardAssets."))
				{
					((Behaviour)val).enabled = false;
					wasBehaviourEnabled[i] = true;
				}
			}
		}

		public static void RestoreStandardAssets(ref MonoBehaviour[] behaviours, ref bool[] wasBehaviourEnabled)
		{
			if (behaviours == null)
			{
				return;
			}
			for (int i = 0; i < behaviours.Length; i++)
			{
				if (wasBehaviourEnabled[i])
				{
					((Behaviour)behaviours[i]).enabled = true;
				}
			}
		}

		public static void ForceForwardRendering(Camera cameraInstance, Mesh clipPlaneMesh, Material forceForwardRenderingMaterial)
		{
			//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_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			Matrix4x4 val = ((Component)cameraInstance).transform.localToWorldMatrix * Matrix4x4.TRS(Vector3.forward * (cameraInstance.nearClipPlane + 0.1f), Quaternion.identity, Vector3.one);
			Graphics.DrawMesh(clipPlaneMesh, val, forceForwardRenderingMaterial, 0, cameraInstance, 0, new MaterialPropertyBlock(), false, false, false);
		}
	}
}
namespace UnityEngine.XR.Interaction.Toolkit
{
	internal static class InputHelpers
	{
		public enum Button
		{
			None = 0,
			MenuButton = 1,
			Trigger = 2,
			Grip = 3,
			TriggerButton = 4,
			GripButton = 5,
			PrimaryButton = 6,
			PrimaryTouch = 7,
			SecondaryButton = 8,
			SecondaryTouch = 9,
			Primary2DAxisTouch = 10,
			Primary2DAxisClick = 11,
			Secondary2DAxisTouch = 12,
			Secondary2DAxisClick = 13,
			PrimaryAxis2DUp = 14,
			PrimaryAxis2DDown = 15,
			PrimaryAxis2DLeft = 16,
			PrimaryAxis2DRight = 17,
			SecondaryAxis2DUp = 18,
			SecondaryAxis2DDown = 19,
			SecondaryAxis2DLeft = 20,
			SecondaryAxis2DRight = 21,
			[Obsolete("TriggerPressed has been deprecated. Use TriggerButton instead. (UnityUpgradable) -> TriggerButton")]
			TriggerPressed = 4,
			[Obsolete("GripPressed has been deprecated. Use GripButton instead. (UnityUpgradable) -> GripButton")]
			GripPressed = 5
		}

		public enum Axis2D
		{
			None,
			PrimaryAxis2D,
			SecondaryAxis2D
		}

		private enum ButtonReadType
		{
			None,
			Binary,
			Axis1D,
			Axis2DUp,
			Axis2DDown,
			Axis2DLeft,
			Axis2DRight
		}

		private struct ButtonInfo
		{
			public string name;

			public ButtonReadType type;

			public ButtonInfo(string name, ButtonReadType type)
			{
				this.name = name;
				this.type = type;
			}
		}

		private static readonly ButtonInfo[] s_ButtonData = new ButtonInfo[22]
		{
			new ButtonInfo("", ButtonReadType.None),
			new ButtonInfo("MenuButton", ButtonReadType.Binary),
			new ButtonInfo("Trigger", ButtonReadType.Axis1D),
			new ButtonInfo("Grip", ButtonReadType.Axis1D),
			new ButtonInfo("TriggerButton", ButtonReadType.Binary),
			new ButtonInfo("GripButton", ButtonReadType.Binary),
			new ButtonInfo("PrimaryButton", ButtonReadType.Binary),
			new ButtonInfo("PrimaryTouch", ButtonReadType.Binary),
			new ButtonInfo("SecondaryButton", ButtonReadType.Binary),
			new ButtonInfo("SecondaryTouch", ButtonReadType.Binary),
			new ButtonInfo("Primary2DAxisTouch", ButtonReadType.Binary),
			new ButtonInfo("Primary2DAxisClick", ButtonReadType.Binary),
			new ButtonInfo("Secondary2DAxisTouch", ButtonReadType.Binary),
			new ButtonInfo("Secondary2DAxisClick", ButtonReadType.Binary),
			new ButtonInfo("Primary2DAxis", ButtonReadType.Axis2DUp),
			new ButtonInfo("Primary2DAxis", ButtonReadType.Axis2DDown),
			new ButtonInfo("Primary2DAxis", ButtonReadType.Axis2DLeft),
			new ButtonInfo("Primary2DAxis", ButtonReadType.Axis2DRight),
			new ButtonInfo("Secondary2DAxis", ButtonReadType.Axis2DUp),
			new ButtonInfo("Secondary2DAxis", ButtonReadType.Axis2DDown),
			new ButtonInfo("Secondary2DAxis", ButtonReadType.Axis2DLeft),
			new ButtonInfo("Secondary2DAxis", ButtonReadType.Axis2DRight)
		};

		private static readonly string[] s_Axis2DNames = new string[3] { "", "Primary2DAxis", "Secondary2DAxis" };

		private const float k_DefaultPressThreshold = 0.1f;

		public static bool IsPressed(this InputDevice device, Button button, out bool isPressed, float pressThreshold = -1f)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			if ((int)button >= s_ButtonData.Length)
			{
				throw new ArgumentException("[InputHelpers.IsPressed] The value of <button> is out of the supported range.");
			}
			if (!((InputDevice)(ref device)).isValid)
			{
				isPressed = false;
				return false;
			}
			ButtonInfo buttonInfo = s_ButtonData[(int)button];
			switch (buttonInfo.type)
			{
			case ButtonReadType.Binary:
			{
				bool flag = default(bool);
				if (((InputDevice)(ref device)).TryGetFeatureValue(new InputFeatureUsage<bool>(buttonInfo.name), ref flag))
				{
					isPressed = flag;
					return true;
				}
				break;
			}
			case ButtonReadType.Axis1D:
			{
				float num3 = default(float);
				if (((InputDevice)(ref device)).TryGetFeatureValue(new InputFeatureUsage<float>(buttonInfo.name), ref num3))
				{
					float num4 = ((pressThreshold >= 0f) ? pressThreshold : 0.1f);
					isPressed = num3 >= num4;
					return true;
				}
				break;
			}
			case ButtonReadType.Axis2DUp:
			{
				Vector2 val3 = default(Vector2);
				if (((InputDevice)(ref device)).TryGetFeatureValue(new InputFeatureUsage<Vector2>(buttonInfo.name), ref val3))
				{
					float num5 = ((pressThreshold >= 0f) ? pressThreshold : 0.1f);
					isPressed = val3.y >= num5;
					return true;
				}
				break;
			}
			case ButtonReadType.Axis2DDown:
			{
				Vector2 val2 = default(Vector2);
				if (((InputDevice)(ref device)).TryGetFeatureValue(new InputFeatureUsage<Vector2>(buttonInfo.name), ref val2))
				{
					float num2 = ((pressThreshold >= 0f) ? pressThreshold : 0.1f);
					isPressed = val2.y <= 0f - num2;
					return true;
				}
				break;
			}
			case ButtonReadType.Axis2DLeft:
			{
				Vector2 val4 = default(Vector2);
				if (((InputDevice)(ref device)).TryGetFeatureValue(new InputFeatureUsage<Vector2>(buttonInfo.name), ref val4))
				{
					float num6 = ((pressThreshold >= 0f) ? pressThreshold : 0.1f);
					isPressed = val4.x <= 0f - num6;
					return true;
				}
				break;
			}
			case ButtonReadType.Axis2DRight:
			{
				Vector2 val = default(Vector2);
				if (((InputDevice)(ref device)).TryGetFeatureValue(new InputFeatureUsage<Vector2>(buttonInfo.name), ref val))
				{
					float num = ((pressThreshold >= 0f) ? pressThreshold : 0.1f);
					isPressed = val.x >= num;
					return true;
				}
				break;
			}
			}
			isPressed = false;
			return false;
		}

		public static bool TryReadSingleValue(this InputDevice device, Button button, out float singleValue)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			if ((int)button >= s_ButtonData.Length)
			{
				throw new ArgumentException("[InputHelpers.TryReadSingleValue] The value of <button> is out of the supported range.");
			}
			if (!((InputDevice)(ref device)).isValid)
			{
				singleValue = 0f;
				return false;
			}
			ButtonInfo buttonInfo = s_ButtonData[(int)button];
			switch (buttonInfo.type)
			{
			case ButtonReadType.Binary:
			{
				bool flag = default(bool);
				if (((InputDevice)(ref device)).TryGetFeatureValue(new InputFeatureUsage<bool>(buttonInfo.name), ref flag))
				{
					singleValue = (flag ? 1f : 0f);
					return true;
				}
				break;
			}
			case ButtonReadType.Axis1D:
			{
				float num = default(float);
				if (((InputDevice)(ref device)).TryGetFeatureValue(new InputFeatureUsage<float>(buttonInfo.name), ref num))
				{
					singleValue = num;
					return true;
				}
				break;
			}
			case ButtonReadType.Axis2DUp:
			{
				Vector2 val2 = default(Vector2);
				if (((InputDevice)(ref device)).TryGetFeatureValue(new InputFeatureUsage<Vector2>(buttonInfo.name), ref val2))
				{
					singleValue = val2.y;
					return true;
				}
				break;
			}
			case ButtonReadType.Axis2DDown:
			{
				Vector2 val4 = default(Vector2);
				if (((InputDevice)(ref device)).TryGetFeatureValue(new InputFeatureUsage<Vector2>(buttonInfo.name), ref val4))
				{
					singleValue = 0f - val4.y;
					return true;
				}
				break;
			}
			case ButtonReadType.Axis2DLeft:
			{
				Vector2 val3 = default(Vector2);
				if (((InputDevice)(ref device)).TryGetFeatureValue(new InputFeatureUsage<Vector2>(buttonInfo.name), ref val3))
				{
					singleValue = 0f - val3.x;
					return true;
				}
				break;
			}
			case ButtonReadType.Axis2DRight:
			{
				Vector2 val = default(Vector2);
				if (((InputDevice)(ref device)).TryGetFeatureValue(new InputFeatureUsage<Vector2>(buttonInfo.name), ref val))
				{
					singleValue = val.x;
					return true;
				}
				break;
			}
			}
			singleValue = 0f;
			return false;
		}

		public static bool TryReadAxis2DValue(this InputDevice device, Axis2D axis2D, out Vector2 value)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if ((int)axis2D >= s_Axis2DNames.Length)
			{
				throw new ArgumentException("[InputHelpers.TryReadAxis2DValue] The value of <axis2D> is out of the supported range.");
			}
			if (!((InputDevice)(ref device)).isValid)
			{
				value = default(Vector2);
				return false;
			}
			string text = s_Axis2DNames[(int)axis2D];
			if (((InputDevice)(ref device)).TryGetFeatureValue(new InputFeatureUsage<Vector2>(text), ref value))
			{
				return true;
			}
			value = default(Vector2);
			return false;
		}
	}
}
namespace VRMod
{
	internal static class ChestHighlighter
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Awake <0>__OnPurchaseAwake;

			public static hook_SetAvailable <1>__OnSetAvailable;

			public static hook_Start <2>__OnStageStart;
		}

		private static readonly List<PurchaseInteraction> tracked = new List<PurchaseInteraction>();

		private static bool hooked;

		internal static void Init()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//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_0049: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			if (!hooked)
			{
				hooked = true;
				object obj = <>O.<0>__OnPurchaseAwake;
				if (obj == null)
				{
					hook_Awake val = OnPurchaseAwake;
					<>O.<0>__OnPurchaseAwake = val;
					obj = (object)val;
				}
				PurchaseInteraction.Awake += (hook_Awake)obj;
				object obj2 = <>O.<1>__OnSetAvailable;
				if (obj2 == null)
				{
					hook_SetAvailable val2 = OnSetAvailable;
					<>O.<1>__OnSetAvailable = val2;
					obj2 = (object)val2;
				}
				PurchaseInteraction.SetAvailable += (hook_SetAvailable)obj2;
				object obj3 = <>O.<2>__OnStageStart;
				if (obj3 == null)
				{
					hook_Start val3 = OnStageStart;
					<>O.<2>__OnStageStart = val3;
					obj3 = (object)val3;
				}
				Stage.Start += (hook_Start)obj3;
			}
		}

		private static IEnumerator OnStageStart(orig_Start orig, Stage self)
		{
			tracked.Clear();
			return orig.Invoke(self);
		}

		private static void OnPurchaseAwake(orig_Awake orig, PurchaseInteraction self)
		{
			orig.Invoke(self);
			if (ModConfig.HighlightChests.Value)
			{
				tracked.Add(self);
				ApplyHighlight(self);
			}
		}

		private static void OnSetAvailable(orig_SetAvailable orig, PurchaseInteraction self, bool newAvailable)
		{
			orig.Invoke(self, newAvailable);
			if (ModConfig.HighlightChests.Value && !newAvailable)
			{
				RemoveHighlight(self);
			}
		}

		private static void ApplyHighlight(PurchaseInteraction purchase)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)purchase) || !purchase.available)
			{
				return;
			}
			GameObject gameObject = ((Component)purchase).gameObject;
			Highlight component = gameObject.GetComponent<Highlight>();
			if (Object.op_Implicit((Object)(object)component) && component.isOn)
			{
				return;
			}
			Highlight val = component ?? gameObject.AddComponent<Highlight>();
			val.highlightColor = (HighlightColor)0;
			val.strength = 1f;
			val.isOn = true;
			if (!Object.op_Implicit((Object)(object)val.targetRenderer))
			{
				Renderer componentInChildren = (Renderer)(object)gameObject.GetComponentInChildren<MeshRenderer>();
				if (!Object.op_Implicit((Object)(object)componentInChildren))
				{
					componentInChildren = (Renderer)(object)gameObject.GetComponentInChildren<SkinnedMeshRenderer>();
				}
				if (Object.op_Implicit((Object)(object)componentInChildren))
				{
					val.targetRenderer = componentInChildren;
				}
			}
		}

		private static void RemoveHighlight(PurchaseInteraction purchase)
		{
			if (Object.op_Implicit((Object)(object)purchase))
			{
				Highlight component = ((Component)purchase).gameObject.GetComponent<Highlight>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.isOn = false;
				}
			}
		}

		internal static void OnSettingChanged(object sender, EventArgs e)
		{
			if (ModConfig.HighlightChests.Value)
			{
				tracked.RemoveAll((PurchaseInteraction x) => !Object.op_Implicit((Object)(object)x));
				{
					foreach (PurchaseInteraction item in tracked)
					{
						if (item.available)
						{
							ApplyHighlight(item);
						}
					}
					return;
				}
			}
			tracked.RemoveAll((PurchaseInteraction x) => !Object.op_Implicit((Object)(object)x));
			foreach (PurchaseInteraction item2 in tracked)
			{
				RemoveHighlight(item2);
			}
		}
	}
	internal static class ItemHints
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_SetItem <0>__OnSetItem;

			public static hook_SetEquipment <1>__OnSetEquipment;

			public static hook_SetContent <2>__OnTooltipSetContent;

			public static hook_SetCurrentPing <3>__OnPing;

			public static hook_SetPickupOptions <4>__OnSetPickupOptions;
		}

		private static bool hooked;

		private const float ExtraDescriptionHeight = 120f;

		internal static void Init()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//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_0049: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			if (!hooked)
			{
				hooked = true;
				object obj = <>O.<0>__OnSetItem;
				if (obj == null)
				{
					hook_SetItem val = OnSetItem;
					<>O.<0>__OnSetItem = val;
					obj = (object)val;
				}
				GenericNotification.SetItem += (hook_SetItem)obj;
				object obj2 = <>O.<1>__OnSetEquipment;
				if (obj2 == null)
				{
					hook_SetEquipment val2 = OnSetEquipment;
					<>O.<1>__OnSetEquipment = val2;
					obj2 = (object)val2;
				}
				GenericNotification.SetEquipment += (hook_SetEquipment)obj2;
				object obj3 = <>O.<2>__OnTooltipSetContent;
				if (obj3 == null)
				{
					hook_SetContent val3 = OnTooltipSetContent;
					<>O.<2>__OnTooltipSetContent = val3;
					obj3 = (object)val3;
				}
				TooltipProvider.SetContent += (hook_SetContent)obj3;
				object obj4 = <>O.<3>__OnPing;
				if (obj4 == null)
				{
					hook_SetCurrentPing val4 = OnPing;
					<>O.<3>__OnPing = val4;
					obj4 = (object)val4;
				}
				PingerController.SetCurrentPing += (hook_SetCurrentPing)obj4;
				object obj5 = <>O.<4>__OnSetPickupOptions;
				if (obj5 == null)
				{
					hook_SetPickupOptions val5 = OnSetPickupOptions;
					<>O.<4>__OnSetPickupOptions = val5;
					obj5 = (object)val5;
				}
				PickupPickerPanel.SetPickupOptions += (hook_SetPickupOptions)obj5;
			}
		}

		private static void OnSetItem(orig_SetItem orig, GenericNotification self, ItemDef itemDef)
		{
			orig.Invoke(self, itemDef);
			if (ModConfig.ItemHints.Value && Object.op_Implicit((Object)(object)itemDef))
			{
				if (!string.IsNullOrEmpty(Language.GetString(itemDef.descriptionToken)) && !Language.IsTokenInvalid(itemDef.descriptionToken) && Object.op_Implicit((Object)(object)self.descriptionText))
				{
					self.descriptionText.token = itemDef.descriptionToken;
				}
				ExpandNotification(self);
			}
		}

		private static void OnSetEquipment(orig_SetEquipment orig, GenericNotification self, EquipmentDef equipmentDef)
		{
			orig.Invoke(self, equipmentDef);
			if (ModConfig.ItemHints.Value && Object.op_Implicit((Object)(object)equipmentDef))
			{
				if (!string.IsNullOrEmpty(Language.GetString(equipmentDef.descriptionToken)) && !Language.IsTokenInvalid(equipmentDef.descriptionToken) && Object.op_Implicit((Object)(object)self.descriptionText))
				{
					self.descriptionText.token = equipmentDef.descriptionToken;
				}
				ExpandNotification(self);
			}
		}

		private static void ExpandNotification(GenericNotification notification)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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_0077: 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)
			if (Object.op_Implicit((Object)(object)notification) && Object.op_Implicit((Object)(object)notification.descriptionText))
			{
				Transform transform = ((Component)notification.descriptionText).transform;
				RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				if (Object.op_Implicit((Object)(object)val))
				{
					val.sizeDelta = new Vector2(val.sizeDelta.x, val.sizeDelta.y + 120f);
				}
				Transform transform2 = ((Component)notification).transform;
				RectTransform val2 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
				if (Object.op_Implicit((Object)(object)val2))
				{
					val2.sizeDelta = new Vector2(val2.sizeDelta.x, val2.sizeDelta.y + 120f);
				}
			}
		}

		private static void OnTooltipSetContent(orig_SetContent orig, TooltipProvider self, TooltipContent content)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (ModConfig.ItemHints.Value)
			{
				TryExpandDescription(ref content);
			}
			orig.Invoke(self, content);
		}

		private static void TryExpandDescription(ref TooltipContent content)
		{
			if (string.IsNullOrEmpty(content.bodyToken) || Language.IsTokenInvalid(content.bodyToken))
			{
				return;
			}
			for (int i = 0; i < ItemCatalog.itemCount; i++)
			{
				ItemDef itemDef = ItemCatalog.GetItemDef((ItemIndex)i);
				if ((Object)(object)itemDef != (Object)null && itemDef.pickupToken == content.bodyToken)
				{
					if (!Language.IsTokenInvalid(itemDef.descriptionToken))
					{
						content.bodyToken = itemDef.descriptionToken;
					}
					return;
				}
			}
			for (int j = 0; j < EquipmentCatalog.equipmentCount; j++)
			{
				EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef((EquipmentIndex)j);
				if ((Object)(object)equipmentDef != (Object)null && equipmentDef.pickupToken == content.bodyToken)
				{
					if (!Language.IsTokenInvalid(equipmentDef.descriptionToken))
					{
						content.bodyToken = equipmentDef.descriptionToken;
					}
					break;
				}
			}
		}

		private static void OnPing(orig_SetCurrentPing orig, PingerController self, PingInfo newPingInfo)
		{
			//IL_0002: 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_0023: 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)
			//IL_0051: Invalid comparison between Unknown and I4
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Invalid comparison between Unknown and I4
			//IL_0054: 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)
			orig.Invoke(self, newPingInfo);
			if (!ModConfig.ItemHints.Value || !Object.op_Implicit((Object)(object)newPingInfo.targetNetworkIdentity))
			{
				return;
			}
			GenericPickupController component = ((Component)newPingInfo.targetNetworkIdentity).GetComponent<GenericPickupController>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				return;
			}
			PickupDef pickupDef = PickupCatalog.GetPickupDef(component.pickupIndex);
			if (pickupDef == null)
			{
				return;
			}
			string text = null;
			if ((int)pickupDef.itemIndex != -1)
			{
				ItemDef itemDef = ItemCatalog.GetItemDef(pickupDef.itemIndex);
				if ((Object)(object)itemDef != (Object)null && !Language.IsTokenInvalid(itemDef.descriptionToken))
				{
					text = Language.GetString(itemDef.descriptionToken);
				}
			}
			else if ((int)pickupDef.equipmentIndex != -1)
			{
				EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(pickupDef.equipmentIndex);
				if ((Object)(object)equipmentDef != (Object)null && !Language.IsTokenInvalid(equipmentDef.descriptionToken))
				{
					text = Language.GetString(equipmentDef.descriptionToken);
				}
			}
			if (!string.IsNullOrEmpty(text))
			{
				Chat.AddMessage("<style=cStack>" + text + "</style>");
			}
		}

		private static void OnSetPickupOptions(orig_SetPickupOptions orig, PickupPickerPanel self, Option[] options)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Expected O, but got Unknown
			if (ModConfig.ItemHints.Value)
			{
				self.maxColumnCount = 6;
				if (Object.op_Implicit((Object)(object)self.gridlayoutGroup))
				{
					self.gridlayoutGroup.constraintCount = 6;
				}
			}
			orig.Invoke(self, options);
			if (!ModConfig.ItemHints.Value || options == null || options.Length == 0)
			{
				return;
			}
			try
			{
				Transform parent = ((Transform)self.buttonContainer).parent;
				GameObject val = new GameObject("ItemHintDescription");
				val.transform.SetParent(parent, false);
				TextMeshProUGUI tmp = val.AddComponent<TextMeshProUGUI>();
				((TMP_Text)tmp).fontSize = 16f;
				((TMP_Text)tmp).alignment = (TextAlignmentOptions)258;
				((TMP_Text)tmp).enableWordWrapping = true;
				((TMP_Text)tmp).overflowMode = (TextOverflowModes)3;
				((Graphic)tmp).color = new Color(0.9f, 0.85f, 0.7f, 1f);
				((TMP_Text)tmp).margin = new Vector4(8f, 4f, 8f, 4f);
				RectTransform component = val.GetComponent<RectTransform>();
				component.anchorMin = new Vector2(0f, 0f);
				component.anchorMax = new Vector2(1f, 0f);
				component.pivot = new Vector2(0.5f, 0f);
				component.anchoredPosition = new Vector2(0f, 8f);
				component.sizeDelta = new Vector2(-16f, 120f);
				((TMP_Text)tmp).text = "";
				ReadOnlyCollection<MPButton> elements = self.buttonAllocator.elements;
				for (int i = 0; i < elements.Count && i < options.Length; i++)
				{
					int num = i;
					MPButton obj = elements[num];
					PickupIndex pickupIndex = options[num].pickup.pickupIndex;
					obj.onSelect.AddListener((UnityAction)delegate
					{
						//IL_000c: Unknown result type (might be due to invalid IL or missing references)
						UpdatePickerDescription(tmp, pickupIndex);
					});
				}
				if (options.Length != 0)
				{
					UpdatePickerDescription(tmp, options[0].pickup.pickupIndex);
				}
			}
			catch (Exception ex)
			{
				Debug.LogWarning((object)("[VRMod] ItemHints: Failed to add picker description: " + ex.Message));
			}
		}

		private static void UpdatePickerDescription(TextMeshProUGUI tmp, PickupIndex pickupIndex)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Invalid comparison between Unknown and I4
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Invalid comparison between Unknown and I4
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)tmp))
			{
				return;
			}
			PickupDef pickupDef = PickupCatalog.GetPickupDef(pickupIndex);
			if (pickupDef == null)
			{
				((TMP_Text)tmp).text = "";
				return;
			}
			string text = null;
			string text2 = null;
			if ((int)pickupDef.itemIndex != -1)
			{
				ItemDef itemDef = ItemCatalog.GetItemDef(pickupDef.itemIndex);
				if ((Object)(object)itemDef != (Object)null)
				{
					text = Language.GetString(itemDef.nameToken);
					if (!Language.IsTokenInvalid(itemDef.descriptionToken))
					{
						text2 = Language.GetString(itemDef.descriptionToken);
					}
				}
			}
			else if ((int)pickupDef.equipmentIndex != -1)
			{
				EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(pickupDef.equipmentIndex);
				if ((Object)(object)equipmentDef != (Object)null)
				{
					text = Language.GetString(equipmentDef.nameToken);
					if (!Language.IsTokenInvalid(equipmentDef.descriptionToken))
					{
						text2 = Language.GetString(equipmentDef.descriptionToken);
					}
				}
			}
			if (!string.IsNullOrEmpty(text) && !string.IsNullOrEmpty(text2))
			{
				((TMP_Text)tmp).text = "<b>" + text + "</b>\n" + text2;
			}
			else if (!string.IsNullOrEmpty(text))
			{
				((TMP_Text)tmp).text = "<b>" + text + "</b>";
			}
			else
			{
				((TMP_Text)tmp).text = "";
			}
		}
	}
	public static class CameraFixes
	{
		internal struct ForcedVisibleRenderer
		{
			internal string bodyName;

			internal string rendererObjectName;

			internal ForcedVisibleRenderer(string bodyName, string rendererObjectName)
			{
				this.bodyName = bodyName;
				this.rendererObjectName = rendererObjectName;
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__RemoveFOVChange;

			public static hook_SetCameraState <1>__SetCameraStateOverride;

			public static Manipulator <2>__UpdateLIVHUDTargetMaster;

			public static Manipulator <3>__GetVRLookInput;

			public static Manipulator <4>__RemoveRecoilAndCameraPitch;

			public static hook_Start <5>__InitCamera;

			public static hook_Update <6>__SetBodyInvisible;

			public static hook_SetEquipmentDisplay <7>__HideFloatingEquipment;

			public static hook_Start <8>__HideFloatingItems;

			public static hook_OnStartClient <9>__HideWoodsprite;

			public static Manipulator <10>__HideTempEffect;

			public static hook_OnEnter <11>__HideSparks;

			public static hook_OnEnter <12>__HideDisc;

			public static hook_OnEnable <13>__FixHUDReference;

			public static Manipulator <14>__ChangeNetworkAngles;

			public static hook_GetCrosshairRaycastRay <15>__GetVRCrosshairRaycastRay;

			public static Manipulator <16>__OnPreRenderIL;

			public static hook_SetOverrideCam <17>__RemoveCameraLerp;

			public static hook_Update <18>__ForceEndOfCurve;

			public static Action <19>__ReplaceLoaderSmokeRampTextures;

			public static Action<Action<PostProcessProfile>, PostProcessProfile> <20>__RemoveDepthOfField;

			public static hook_Awake <21>__AddStereoProjectionFix;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_Awake <>9__22_0;

			public static hook_OnDestroy <>9__22_1;

			public static hook_UpdateCameras <>9__22_2;

			public static Func<Instruction, bool> <>9__25_0;

			public static Func<PitchYawPair> <>9__25_1;

			public static Func<Instruction, bool> <>9__27_0;

			public static Func<CharacterCameraParamsData, CameraModePlayerBasic, float> <>9__27_1;

			public static Func<Instruction, bool> <>9__27_2;

			public static Func<CharacterCameraParamsData, CameraModePlayerBasic, float> <>9__27_3;

			public static Func<Instruction, bool> <>9__27_4;

			public static Func<Instruction, bool> <>9__28_0;

			public static Action<CharacterMaster> <>9__28_1;

			public static Func<SerializedField, bool> <>9__29_0;

			public static Func<SerializedField, bool> <>9__29_1;

			public static Func<Instruction, bool> <>9__33_0;

			public static Func<DecaliciousRenderer, bool> <>9__33_1;

			public static Func<Instruction, bool> <>9__33_2;

			public static Func<Instruction, bool> <>9__37_0;

			public static Action<CharacterBody, TemporaryVisualEffect> <>9__37_1;

			public static Func<Instruction, bool> <>9__42_0;

			public static Func<Instruction, bool> <>9__42_1;

			public static Func<Player, Vector2> <>9__42_2;

			public static Func<Player, Vector2> <>9__42_3;

			public static Func<Instruction, bool> <>9__42_4;

			public static Func<Instruction, bool> <>9__42_5;

			public static Func<Vector2, Vector2, Vector2> <>9__42_6;

			public static Func<bool> <>9__42_7;

			public static Func<Instruction, bool> <>9__45_0;

			public static Func<Instruction, bool> <>9__45_1;

			internal void <Init>b__22_0(orig_Awake orig, MatchCamera self)
			{
				self.matchFOV = false;
				orig.Invoke(self);
			}

			internal void <Init>b__22_1(orig_OnDestroy orig, CameraRigController self)
			{
				orig.Invoke(self);
				if (Object.op_Implicit((Object)(object)VRCameraWrapper.instance))
				{
					Object.Destroy((Object)(object)((Component)VRCameraWrapper.instance).gameObject);
				}
			}

			internal void <Init>b__22_2(orig_UpdateCameras orig, SurvivorPodController self, GameObject gameObject)
			{
			}

			internal bool <ChangeNetworkAngles>b__25_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<NetworkedViewAngles>(x, "viewAngles");
			}

			internal PitchYawPair <ChangeNetworkAngles>b__25_1()
			{
				//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_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				Vector3 forward = ((Component)Camera.main).transform.forward;
				float num = Mathf.Sqrt(forward.x * forward.x + forward.z * forward.z);
				return new PitchYawPair(Mathf.Atan2(0f - forward.y, num) * 57.29578f, Mathf.Repeat(Mathf.Atan2(forward.x, forward.z) * 57.29578f, 360f));
			}

			internal bool <RemoveRecoilAndCameraPitch>b__27_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld(x, typeof(CharacterCameraParamsData), "minPitch");
			}

			internal float <RemoveRecoilAndCameraPitch>b__27_1(CharacterCameraParamsData camParams, CameraModePlayerBasic camMode)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				if (!ModConfig.TempLockedCameraPitchValue || camMode.isSpectatorMode)
				{
					return camParams.minPitch.value;
				}
				return 0f;
			}

			internal bool <RemoveRecoilAndCameraPitch>b__27_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld(x, typeof(CharacterCameraParamsData), "maxPitch");
			}

			internal float <RemoveRecoilAndCameraPitch>b__27_3(CharacterCameraParamsData camParams, CameraModePlayerBasic camMode)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				if (!ModConfig.TempLockedCameraPitchValue || camMode.isSpectatorMode)
				{
					return camParams.maxPitch.value;
				}
				return 0f;
			}

			internal bool <RemoveRecoilAndCameraPitch>b__27_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdloc(x, 10);
			}

			internal bool <UpdateLIVHUDTargetMaster>b__28_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallvirt(x, typeof(HUD), "set_targetMaster");
			}

			internal void <UpdateLIVHUDTargetMaster>b__28_1(CharacterMaster master)
			{
				if (Object.op_Implicit((Object)(object)UIFixes.livHUD))
				{
					UIFixes.livHUD.targetMaster = master;
				}
			}

			internal bool <ReplaceLoaderSmokeRampTextures>b__29_0(SerializedField x)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return x.fieldName == "chargeVfxPrefab";
			}

			internal bool <ReplaceLoaderSmokeRampTextures>b__29_1(SerializedField x)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return x.fieldName == "swingEffectPrefab";
			}

			internal bool <OnPreRenderIL>b__33_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchCall<DecaliciousRenderer>(x, "DrawUnlitDecals");
			}

			internal bool <OnPreRenderIL>b__33_1(DecaliciousRenderer self)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				if ((int)self._camera.stereoTargetEye == 0)
				{
					return true;
				}
				bool num = lastFrameCount == Time.renderedFrameCount;
				if (num)
				{
					lastFrameCount = Time.renderedFrameCount;
				}
				return num;
			}

			internal bool <OnPreRenderIL>b__33_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<DecaliciousRenderer>(x, "_limitToGameObjects");
			}

			internal bool <HideTempEffect>b__37_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<TemporaryVisualEffect>(x, "radius");
			}

			internal void <HideTempEffect>b__37_1(CharacterBody body, TemporaryVisualEffect effect)
			{
				if (body.IsLocalBody())
				{
					Renderer[] componentsInChildren = ((Component)effect).GetComponentsInChildren<Renderer>();
					for (int i = 0; i < componentsInChildren.Length; i++)
					{
						componentsInChildren[i].enabled = false;
					}
				}
			}

			internal bool <GetVRLookInput>b__42_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdflda(x, typeof(CameraModeContext), "targetInfo");
			}

			internal bool <GetVRLookInput>b__42_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdloca(x, 6);
			}

			internal Vector2 <GetVRLookInput>b__42_2(Player player)
			{
				//IL_0039: 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)
				if (!ModConfig.InitialMotionControlsValue)
				{
					return new Vector2(player.GetAxisRaw(ModConfig.SnapTurn.Value ? 26 : 2), ModConfig.TempLockedCameraPitchValue ? 0f : player.GetAxisRaw(3));
				}
				return Vector2.zero;
			}

			internal Vector2 <GetVRLookInput>b__42_3(Player player)
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				return new Vector2(player.GetAxisRaw(16), ModConfig.TempLockedCameraPitchValue ? 0f : player.GetAxisRaw(17));
			}

			internal bool <GetVRLookInput>b__42_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchCall(x, typeof(CameraModePlayerBasic), "PerformAimAssist");
			}

			internal bool <GetVRLookInput>b__42_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdflda(x, typeof(CameraInfo), "previousCameraState");
			}

			internal Vector2 <GetVRLookInput>b__42_6(Vector2 mouseVector, Vector2 joystickVector)
			{
				//IL_0014: 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_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				wasTurningLeft = isTurningLeft;
				wasTurningRight = isTurningRight;
				isTurningLeft = joystickVector.x < -0.8f;
				isTurningRight = joystickVector.x > 0.8f;
				if (!ModConfig.MotionControlsEnabled)
				{
					isTurningLeft = isTurningLeft || mouseVector.x < -0.8f;
					isTurningRight = isTurningRight || mouseVector.x > 0.8f;
				}
				Vector2 zero = Vector2.zero;
				if (justTurnedLeft)
				{
					zero.x = -ModConfig.SnapTurnAngle.Value;
				}
				else if (justTurnedRight)
				{
					zero.x = ModConfig.SnapTurnAngle.Value;
				}
				if ((isTurningLeft || isTurningRight) && timeSinceLastSnapTurn <= ModConfig.SnapTurnHoldDelay.Value)
				{
					timeSinceLastSnapTurn += Time.deltaTime;
				}
				else
				{
					timeSinceLastSnapTurn = 0f;
				}
				return zero;
			}

			internal bool <GetVRLookInput>b__42_7()
			{
				return ModConfig.SnapTurn.Value;
			}

			internal bool <RemoveFOVChange>b__45_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdarg(x, 1);
			}

			internal bool <RemoveFOVChange>b__45_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<CameraState>(x, "fov");
			}
		}

		private static bool isTurningLeft;

		private static bool wasTurningLeft;

		private static bool isTurningRight;

		private static bool wasTurningRight;

		private static float timeSinceLastSnapTurn = 0f;

		private static int lastFrameCount = -1;

		private static GameObject spectatorCamera;

		private static GameObject spectatorScreen;

		private static Camera spectatorCameraComponent;

		private static GameObject spectatorCameraPrefab;

		private static GameObject spectatorScreenPrefab;

		private static Transform cachedCameraTargetTransform;

		private static List<ForcedVisibleRenderer> forcedVisibleRenderers;

		private static Transform cameraOffset;

		private static bool justTurnedLeft
		{
			get
			{
				if (isTurningLeft)
				{
					if (wasTurningLeft)
					{
						return timeSinceLastSnapTurn > ModConfig.SnapTurnHoldDelay.Value;
					}
					return true;
				}
				return false;
			}
		}

		private static bool justTurnedRight
		{
			get
			{
				if (isTurningRight)
				{
					if (wasTurningRight)
					{
						return timeSinceLastSnapTurn > ModConfig.SnapTurnHoldDelay.Value;
					}
					return true;
				}
				return false;
			}
		}

		internal static LIV.SDK.Unity.LIV liv { get; private set; }

		internal static void Init()
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//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_00b7: Expected O, but got Unknown
			//IL_00cc: 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_00d7: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Expected O, but got Unknown
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Expected O, but got Unknown
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Expected O, but got Unknown
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Expected O, but got Unknown
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Expected O, but got Unknown
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Expected O, but got Unknown
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Expected O, but got Unknown
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Expected O, but got Unknown
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Expected O, but got Unknown
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Expected O, but got Unknown
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Expected O, but got Unknown
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Expected O, but got Unknown
			//IL_0398: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Expected O, but got Unknown
			//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: Expected O, but got Unknown
			//IL_023a: 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_0245: Expected O, but got Unknown
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Expected O, but got Unknown
			spectatorCameraPrefab = VRMod.VRAssetBundle.LoadAsset<GameObject>("SpectatorCamera");
			spectatorCameraPrefab.GetComponent<Camera>().stereoTargetEye = (StereoTargetEyeMask)0;
			spectatorScreenPrefab = VRMod.VRAssetBundle.LoadAsset<GameObject>("SpectatorScreen");
			object obj = <>c.<>9__22_0;
			if (obj == null)
			{
				hook_Awake val = delegate(orig_Awake orig, MatchCamera self)
				{
					self.matchFOV = false;
					orig.Invoke(self);
				};
				<>c.<>9__22_0 = val;
				obj = (object)val;
			}
			MatchCamera.Awake += (hook_Awake)obj;
			object obj2 = <>O.<0>__RemoveFOVChange;
			if (obj2 == null)
			{
				Manipulator val2 = RemoveFOVChange;
				<>O.<0>__RemoveFOVChange = val2;
				obj2 = (object)val2;
			}
			CameraRigController.SetCameraState += (Manipulator)obj2;
			object obj3 = <>O.<1>__SetCameraStateOverride;
			if (obj3 == null)
			{
				hook_SetCameraState val3 = SetCameraStateOverride;
				<>O.<1>__SetCameraStateOverride = val3;
				obj3 = (object)val3;
			}
			CameraRigController.SetCameraState += (hook_SetCameraState)obj3;
			object obj4 = <>O.<2>__UpdateLIVHUDTargetMaster;
			if (obj4 == null)
			{
				Manipulator val4 = UpdateLIVHUDTargetMaster;
				<>O.<2>__UpdateLIVHUDTargetMaster = val4;
				obj4 = (object)val4;
			}
			CameraRigController.LateUpdate += (Manipulator)obj4;
			object obj5 = <>O.<3>__GetVRLookInput;
			if (obj5 == null)
			{
				Manipulator val5 = GetVRLookInput;
				<>O.<3>__GetVRLookInput = val5;
				obj5 = (object)val5;
			}
			CameraModePlayerBasic.CollectLookInputInternal += (Manipulator)obj5;
			object obj6 = <>O.<4>__RemoveRecoilAndCameraPitch;
			if (obj6 == null)
			{
				Manipulator val6 = RemoveRecoilAndCameraPitch;
				<>O.<4>__RemoveRecoilAndCameraPitch = val6;
				obj6 = (object)val6;
			}
			CameraModePlayerBasic.UpdateInternal += (Manipulator)obj6;
			object obj7 = <>O.<5>__InitCamera;
			if (obj7 == null)
			{
				hook_Start val7 = InitCamera;
				<>O.<5>__InitCamera = val7;
				obj7 = (object)val7;
			}
			CameraRigController.Start += (hook_Start)obj7;
			if (ModConfig.InitialFirstPersonValue)
			{
				object obj8 = <>O.<6>__SetBodyInvisible;
				if (obj8 == null)
				{
					hook_Update val8 = SetBodyInvisible;
					<>O.<6>__SetBodyInvisible = val8;
					obj8 = (object)val8;
				}
				Run.Update += (hook_Update)obj8;
				object obj9 = <>c.<>9__22_1;
				if (obj9 == null)
				{
					hook_OnDestroy val9 = delegate(orig_OnDestroy orig, CameraRigController self)
					{
						orig.Invoke(self);
						if (Object.op_Implicit((Object)(object)VRCameraWrapper.instance))
						{
							Object.Destroy((Object)(object)((Component)VRCameraWrapper.instance).gameObject);
						}
					};
					<>c.<>9__22_1 = val9;
					obj9 = (object)val9;
				}
				CameraRigController.OnDestroy += (hook_OnDestroy)obj9;
				object obj10 = <>O.<7>__HideFloatingEquipment;
				if (obj10 == null)
				{
					hook_SetEquipmentDisplay val10 = HideFloatingEquipment;
					<>O.<7>__HideFloatingEquipment = val10;
					obj10 = (object)val10;
				}
				CharacterModel.SetEquipmentDisplay += (hook_SetEquipmentDisplay)obj10;
				object obj11 = <>O.<8>__HideFloatingItems;
				if (obj11 == null)
				{
					hook_Start val11 = HideFloatingItems;
					<>O.<8>__HideFloatingItems = val11;
					obj11 = (object)val11;
				}
				ItemFollower.Start += (hook_Start)obj11;
				object obj12 = <>O.<9>__HideWoodsprite;
				if (obj12 == null)
				{
					hook_OnStartClient val12 = HideWoodsprite;
					<>O.<9>__HideWoodsprite = val12;
					obj12 = (object)val12;
				}
				HealingFollowerController.OnStartClient += (hook_OnStartClient)obj12;
				object obj13 = <>O.<10>__HideTempEffect;
				if (obj13 == null)
				{
					Manipulator val13 = HideTempEffect;
					<>O.<10>__HideTempEffect = val13;
					obj13 = (object)val13;
				}
				CharacterBody.UpdateSingleTemporaryVisualEffect_refTemporaryVisualEffect_GameObject_float_bool_string += (Manipulator)obj13;
				object obj14 = <>O.<11>__HideSparks;
				if (obj14 == null)
				{
					hook_OnEnter val14 = HideSparks;
					<>O.<11>__HideSparks = val14;
					obj14 = (object)val14;
				}
				BaseVagrantNovaItemState.OnEnter += (hook_OnEnter)obj14;
				object obj15 = <>O.<12>__HideDisc;
				if (obj15 == null)
				{
					hook_OnEnter val15 = HideDisc;
					<>O.<12>__HideDisc = val15;
					obj15 = (object)val15;
				}
				LaserTurbineBaseState.OnEnter += (hook_OnEnter)obj15;
				object obj16 = <>O.<13>__FixHUDReference;
				if (obj16 == null)
				{
					hook_OnEnable val16 = FixHUDReference;
					<>O.<13>__FixHUDReference = val16;
					obj16 = (object)val16;
				}
				HudObjectiveTargetSetter.OnEnable += (hook_OnEnable)obj16;
				object obj17 = <>O.<14>__ChangeNetworkAngles;
				if (obj17 == null)
				{
					Manipulator val17 = ChangeNetworkAngles;
					<>O.<14>__ChangeNetworkAngles = val17;
					obj17 = (object)val17;
				}
				CameraModePlayerBasic.ApplyLookInputInternal += (Manipulator)obj17;
			}
			object obj18 = <>O.<15>__GetVRCrosshairRaycastRay;
			if (obj18 == null)
			{
				hook_GetCrosshairRaycastRay val18 = GetVRCrosshairRaycastRay;
				<>O.<15>__GetVRCrosshairRaycastRay = val18;
				obj18 = (object)val18;
			}
			CameraModePlayerBasic.GetCrosshairRaycastRay += (hook_GetCrosshairRaycastRay)obj18;
			MethodInfo? method = typeof(DecaliciousRenderer).GetMethod("OnPreRender", BindingFlags.Instance | BindingFlags.NonPublic);
			object obj19 = <>O.<16>__OnPreRenderIL;
			if (obj19 == null)
			{
				Manipulator val19 = OnPreRenderIL;
				<>O.<16>__OnPreRenderIL = val19;
				obj19 = (object)val19;
			}
			new ILHook((MethodBase)method, (Manipulator)obj19);
			object obj20 = <>c.<>9__22_2;
			if (obj20 == null)
			{
				hook_UpdateCameras val20 = delegate
				{
				};
				<>c.<>9__22_2 = val20;
				obj20 = (object)val20;
			}
			SurvivorPodController.UpdateCameras += (hook_UpdateCameras)obj20;
			object obj21 = <>O.<17>__RemoveCameraLerp;
			if (obj21 == null)
			{
				hook_SetOverrideCam val21 = RemoveCameraLerp;
				<>O.<17>__RemoveCameraLerp = val21;
				obj21 = (object)val21;
			}
			CameraRigController.SetOverrideCam += (hook_SetOverrideCam)obj21;
			object obj22 = <>O.<18>__ForceEndOfCurve;
			if (obj22 == null)
			{
				hook_Update val22 = ForceEndOfCurve;
				<>O.<18>__ForceEndOfCurve = val22;
				obj22 = (object)val22;
			}
			PositionAlongBasicBezierSpline.Update += (hook_Update)obj22;
			if (ModConfig.InitialRoomscaleValue && !ModConfig.InitialOculusModeValue)
			{
				SDKShaders.LoadShaders();
			}
			RoR2Application.onLoad = (Action)Delegate.Combine(RoR2Application.onLoad, new Action(ReplaceLoaderSmokeRampTextures));
			new Hook((MethodBase)typeof(PostProcessProfile).GetMethod("OnEnable", BindingFlags.Instance | BindingFlags.NonPublic), (Delegate)new Action<Action<PostProcessProfile>, PostProcessProfile>(RemoveDepthOfField));
			object obj23 = <>O.<21>__AddStereoProjectionFix;
			if (obj23 == null)
			{
				hook_Awake val23 = AddStereoProjectionFix;
				<>O.<21>__AddStereoProjectionFix = val23;
				obj23 = (object)val23;
			}
			SceneCamera.Awake += (hook_Awake)obj23;
		}

		private static void AddStereoProjectionFix(orig_Awake orig, SceneCamera self)
		{
			((Component)self).gameObject.AddComponent<StereoProjectionFix>();
			orig.Invoke(self);
		}

		private static void RemoveDepthOfField(Action<PostProcessProfile> orig, PostProcessProfile self)
		{
			orig(self);
			DepthOfField setting = self.GetSetting<DepthOfField>();
			if (Object.op_Implicit((Object)(object)setting))
			{
				((PostProcessEffectSettings)setting).active = false;
			}
		}

		private static void ChangeNetworkAngles(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			ILCursor val = new ILCursor(il);
			val.GotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchStfld<NetworkedViewAngles>(x, "viewAngles")
			});
			val.Index -= 2;
			val.RemoveRange(2);
			val.EmitDelegate<Func<PitchYawPair>>((Func<PitchYawPair>)delegate
			{
				//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_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				Vector3 forward = ((Component)Camera.main).transform.forward;
				float num = Mathf.Sqrt(forward.x * forward.x + forward.z * forward.z);
				return new PitchYawPair(Mathf.Atan2(0f - forward.y, num) * 57.29578f, Mathf.Repeat(Mathf.Atan2(forward.x, forward.z) * 57.29578f, 360f));
			});
		}

		private static void FixHUDReference(orig_OnEnable orig, HudObjectiveTargetSetter self)
		{
			orig.Invoke(self);
			if ((Object)(object)self.hud == (Object)null && Object.op_Implicit((Object)(object)Utils.localCameraRig) && Object.op_Implicit((Object)(object)Utils.localCameraRig.hud))
			{
				self.hud = Utils.localCameraRig.hud;
			}
		}

		private static void RemoveRecoilAndCameraPitch(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.GotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdfld(x, typeof(CharacterCameraParamsData), "minPitch")
			});
			val.RemoveRange(2);
			val.Emit(OpCodes.Ldarg_0);
			val.EmitDelegate<Func<CharacterCameraParamsData, CameraModePlayerBasic, float>>((Func<CharacterCameraParamsData, CameraModePlayerBasic, float>)((CharacterCameraParamsData camParams, CameraModePlayerBasic camMode) => (!ModConfig.TempLockedCameraPitchValue || camMode.isSpectatorMode) ? camParams.minPitch.value : 0f));
			val.GotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdfld(x, typeof(CharacterCameraParamsData), "maxPitch")
			});
			val.RemoveRange(2);
			val.Emit(OpCodes.Ldarg_0);
			val.EmitDelegate<Func<CharacterCameraParamsData, CameraModePlayerBasic, float>>((Func<CharacterCameraParamsData, CameraModePlayerBasic, float>)((CharacterCameraParamsData camParams, CameraModePlayerBasic camMode) => (!ModConfig.TempLockedCameraPitchValue || camMode.isSpectatorMode) ? camParams.maxPitch.value : 0f));
			val.GotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 10)
			});
			val.RemoveRange(10);
		}

		private static void UpdateLIVHUDTargetMaster(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.GotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallvirt(x, typeof(HUD), "set_targetMaster")
			});
			int index = val.Index;
			val.Index = index + 1;
			val.Emit(OpCodes.Ldloc_S, (byte)6);
			val.EmitDelegate<Action<CharacterMaster>>((Action<CharacterMaster>)delegate(CharacterMaster master)
			{
				if (Object.op_Implicit((Object)(object)UIFixes.livHUD))
				{
					UIFixes.livHUD.targetMaster = master;
				}
			});
		}

		private static void ReplaceLoaderSmokeRampTextures()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			Texture2D rampTexture = VRMod.VRAssetBundle.LoadAsset<Texture2D>("SmokeRamp");
			EntityStateConfiguration val = LegacyResourcesAPI.Load<EntityStateConfiguration>("entitystateconfigurations/EntityStates.Loader.BaseChargeFist");
			if (Object.op_Implicit((Object)(object)val))
			{
				Object objectValue = val.serializedFieldsCollection.serializedFields.First((SerializedField x) => x.fieldName == "chargeVfxPrefab").fieldValue.objectValue;
				Transform val2 = ((GameObject)((objectValue is GameObject) ? objectValue : null)).transform.Find("Dust");
				if (Object.op_Implicit((Object)(object)val2))
				{
					ReplaceSmokeRampTexture(val2, rampTexture);
				}
			}
			val = LegacyResourcesAPI.Load<EntityStateConfiguration>("entitystateconfigurations/EntityStates.Loader.BaseSwingChargedFist");
			if (Object.op_Implicit((Object)(object)val))
			{
				Object objectValue2 = val.serializedFieldsCollection.serializedFields.First((SerializedField x) => x.fieldName == "swingEffectPrefab").fieldValue.objectValue;
				Transform val3 = ((GameObject)((objectValue2 is GameObject) ? objectValue2 : null)).transform.Find("Dust");
				if (Object.op_Implicit((Object)(object)val3))
				{
					ReplaceSmokeRampTexture(val3, rampTexture);
				}
			}
			GameObject val4 = LegacyResourcesAPI.Load<GameObject>("prefabs/projectiles/LoaderHook");
			if (Object.op_Implicit((Object)(object)val4))
			{
				Transform val5 = val4.transform.Find("FistMesh/RopeFront/Dust");
				if (Object.op_Implicit((Object)(object)val5))
				{
					ReplaceSmokeRampTexture(val5, rampTexture);
				}
				val5 = val4.transform.Find("RopeEnd/Dust");
				if (Object.op_Implicit((Object)(object)val5))
				{
					ReplaceSmokeRampTexture(val5, rampTexture);
				}
			}
		}

		private static void ReplaceSmokeRampTexture(Transform effect, Texture2D rampTexture)
		{
			Material material = ((Renderer)((Component)effect).GetComponent<ParticleSystemRenderer>()).material;
			if (Object.op_Implicit((Object)(object)material))
			{
				material.SetTexture("_RemapTex", (Texture)(object)rampTexture);
				material.SetFloat("_AlphaBias", 0.005f);
				material.SetFloat("_InvFade", 0f);
			}
		}

		private static void ForceEndOfCurve(orig_Update orig, PositionAlongBasicBezierSpline self)
		{
			if (Object.op_Implicit((Object)(object)((Component)self).GetComponent<PlayableDirector>()))
			{
				self.normalizedPositionAlongCurve = 1f;
			}
			orig.Invoke(self);
		}

		private static void RemoveCameraLerp(orig_SetOverrideCam orig, CameraRigController self, ICameraStateProvider newOverrideCam, float lerpDuration)
		{
			orig.Invoke(self, newOverrideCam, 0f);
		}

		private static void OnPreRenderIL(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.GotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCall<DecaliciousRenderer>(x, "DrawUnlitDecals")
			});
			int index = val.Index;
			val.Index = index + 1;
			val.Emit(OpCodes.Ldarg_0);
			val.EmitDelegate<Func<DecaliciousRenderer, bool>>((Func<DecaliciousRenderer, bool>)delegate(DecaliciousRenderer self)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				if ((int)self._camera.stereoTargetEye != 0)
				{
					bool num = lastFrameCount == Time.renderedFrameCount;
					if (num)
					{
						lastFrameCount = Time.renderedFrameCount;
					}
					return num;
				}
				return true;
			});
			int index2 = val.Index;
			val.GotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdfld<DecaliciousRenderer>(x, "_limitToGameObjects")
			});
			index = val.Index;
			val.Index = index - 1;
			ILLabel val2 = val.MarkLabel();
			val.Index = index2;
			val.Emit(OpCodes.Brfalse_S, (object)val2);
		}

		private static void HideFloatingItems(orig_Start orig, ItemFollower self)
		{
			CharacterModel componentInParent = ((Component)self).GetComponentInParent<CharacterModel>();
			if (Object.op_Implicit((Object)(object)componentInParent) && componentInParent.body.IsLocalBody())
			{
				((Behaviour)self).enabled = false;
			}
			else
			{
				orig.Invoke(self);
			}
		}

		private static void HideDisc(orig_OnEnter orig, LaserTurbineBaseState self)
		{
			orig.Invoke(self);
			if (self.ownerBody.IsLocalBody())
			{
				self.laserTurbineController.showTurbineDisplay = false;
			}
		}

		private static void HideSparks(orig_OnEnter orig, BaseVagrantNovaItemState self)
		{
			orig.Invoke(self);
			if (((BaseBodyAttachmentState)self).attachedBody.IsLocalBody() && Object.op_Implicit((Object)(object)self.chargeSparks))
			{
				self.chargeSparks.Stop();
			}
		}

		private static void HideTempEffect(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0047: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.GotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchStfld<TemporaryVisualEffect>(x, "radius")
			});
			int index = val.Index;
			val.Index = index + 1;
			val.Emit(OpCodes.Ldarg_0);
			val.Emit(OpCodes.Ldarg_1);
			val.Emit(OpCodes.Ldind_Ref);
			val.EmitDelegate<Action<CharacterBody, TemporaryVisualEffect>>((Action<CharacterBody, TemporaryVisualEffect>)delegate(CharacterBody body, TemporaryVisualEffect effect)
			{
				if (body.IsLocalBody())
				{
					Renderer[] componentsInChildren = ((Component)effect).GetComponentsInChildren<Renderer>();
					for (int i = 0; i < componentsInChildren.Length; i++)
					{
						componentsInChildren[i].enabled = false;
					}
				}
			});
		}

		public static void PreventRendererDisable(string bodyName, string rendererObjectName)
		{
			if (forcedVisibleRenderers == null)
			{
				forcedVisibleRenderers = new List<ForcedVisibleRenderer>();
			}
			forcedVisibleRenderers.Add(new ForcedVisibleRenderer(bodyName, rendererObjectName));
		}

		private static void HideWoodsprite(orig_OnStartClient orig, HealingFollowerController self)
		{
			orig.Invoke(self);
			if (!((Object)(object)self.ownerBodyObject != (Object)(object)LocalUserManager.GetFirstLocalUser().cachedBodyObject))
			{
				Renderer[] componentsInChildren = ((Component)self).GetComponentsInChildren<Renderer>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					componentsInChildren[i].enabled = false;
				}
			}
		}

		private static void HideFloatingEquipment(orig_SetEquipmentDisplay orig, CharacterModel self, EquipmentIndex newEquipmentIndex)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected I4, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected I4, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected I4, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected I4, but got Unknown
			//IL_0058: 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)
			EquipmentIndex[] source = (EquipmentIndex[])(object)new EquipmentIndex[4]
			{
				(EquipmentIndex)(int)Equipment.Blackhole.equipmentIndex,
				(EquipmentIndex)(int)Equipment.Saw.equipmentIndex,
				(EquipmentIndex)(int)Equipment.PassiveHealing.equipmentIndex,
				(EquipmentIndex)(int)Equipment.Meteor.equipmentIndex
			};
			if (!self.body.master.IsLocalMaster() || !source.Contains(newEquipmentIndex))
			{
				orig.Invoke(self, newEquipmentIndex);
			}
		}

		private static void InitCamera(orig_Start orig, CameraRigController self)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: 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_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			if (self.sceneCam.cullingMask == (self.sceneCam.cullingMask | (1 << LayerIndex.triggerZone.intVal)))
			{
				Camera sceneCam = self.sceneCam;
				sceneCam.cullingMask &= ~(1 << LayerIndex.triggerZone.intVal);
			}
			if (self.sceneCam.cullingMask == (self.sceneCam.cullingMask | (1 << LayerIndex.noDraw.intVal)))
			{
				Camera sceneCam2 = self.sceneCam;
				sceneCam2.cullingMask &= ~(1 << LayerIndex.noDraw.intVal);
			}
			Scene scene = ((Component)self).gameObject.scene;
			if (((Scene)(ref scene)).name == "intro" && self.sceneCam.cullingMask == (self.sceneCam.cullingMask | (1 << LayerIndex.ui.intVal)))
			{
				Camera sceneCam3 = self.sceneCam;
				sceneCam3.cullingMask &= ~(1 << LayerIndex.ui.intVal);
			}
			TrackedPoseDriver obj = ((Component)self.sceneCam).gameObject.AddComponent<TrackedPoseDriver>();
			obj.SetPoseSource((DeviceType)0, (TrackedPose)3);
			obj.trackingType = (TrackingType)0;
			obj.updateType = (UpdateType)0;
			TrackedPoseDriver obj2 = ((Component)self.uiCam).gameObject.AddComponent<TrackedPoseDriver>();
			obj2.SetPoseSource((DeviceType)0, (TrackedPose)3);
			obj2.trackingType = (TrackingType)0;
			obj2.updateType = (UpdateType)0;
			if (Object.op_Implicit((Object)(object)Run.instance) && ModConfig.UseConfortVignette.Value)
			{
				((Component)self.uiCam).gameObject.AddComponent<ConfortVignette>();
			}
			cameraOffset = new GameObject("Camera Offset").transform;
			((Component)cameraOffset).transform.SetParent(((Component)self).transform);
			((Component)cameraOffset).transform.localPosition = Vector3.zero;
			((Component)cameraOffset).transform.localRotation = Quaternion.identity;
			((Component)cameraOffset).transform.localScale = Vector3.one;
			((Component)self.sceneCam).transform.SetParent(((Component)cameraOffset).transform);
			if (ModConfig.InitialRoomscaleValue && !Object.op_Implicit((Object)(object)Run.instance))
			{
				self.currentCameraState = self.desiredCameraState;
			}
			if (!ModConfig.InitialOculusModeValue && ModConfig.InitialRoomscaleValue)
			{
				if (Object.op_Implicit((Object)(object)liv))
				{
					Object.Destroy((Object)(object)liv);
				}
				liv = ((Component)self).gameObject.AddComponent<LIV.SDK.Unity.LIV>();
				liv.stage = ((Component)self).transform;
				liv.stageTransform = ((Component)cameraOffset).transform;
				liv.HMDCamera = self.sceneCam;
				liv.excludeBehaviours = new string[5] { "AkAudioListener", "Rigidbody", "AkGameObj", "CameraResolutionScaler", "TranslucentImageSource" };
				liv.spectatorLayerMask = LayerMask.op_Implicit(self.sceneCam.cullingMask);
				((Behaviour)liv).enabled = true;
			}
			if (Object.op_Implicit((Object)(object)self.hud))
			{
				UIFixes.AdjustHUD(self.hud);
			}
			RoR2Application.instance.mainCanvas.worldCamera = self.uiCam;
			if (Object.op_Implicit((Object)(object)FocusChecker.instance))
			{
				FocusChecker.instance.UpdateCameraRig(self);
			}
			if (Object.op_Implicit((Object)(object)UIFixes.queuedKickDialog))
			{
				Canvas componentInChildren = UIFixes.queuedKickDialog.GetComponentInChildren<Canvas>();
				if (Object.op_Implicit((Object)(object)componentInChildren))
				{
					componentInChildren.worldCamera = self.uiCam;
				}
			}
		}

		private static void GetVRLookInput(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.GotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdflda(x, typeof(CameraModeContext), "targetInfo")
			});
			int index = val.Index;
			val.Index = index - 1;
			val.RemoveRange(2);
			val.GotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdloca(x, 6)
			});
			ILLabel obj = val.IncomingLabels.First();
			index = val.Index;
			val.Index = index + 1;
			obj.Target = val.Next;
			index = val.Index;
			val.Index = index - 1;
			val.Remove();
			index = val.Index;
			val.Index = index + 1;
			val.RemoveRange(6);
			val.EmitDelegate<Func<Player, Vector2>>((Func<Player, Vector2>)((Player player) => (Vector2)((!ModConfig.InitialMotionControlsValue) ? new Vector2(player.GetAxisRaw(ModConfig.SnapTurn.Value ? 26 : 2), ModConfig.TempLockedCameraPitchValue ? 0f : player.GetAxisRaw(3)) : Vector2.zero)));
			val.Emit(OpCodes.Stloc_S, (byte)6);
			val.Remove();
			index = val.Index;
			val.Index = index + 1;
			val.RemoveRange(6);
			val.EmitDelegate<Func<Player, Vector2>>((Func<Player, Vector2>)((Player player) => new Vector2(player.GetAxisRaw(16), ModConfig.TempLockedCameraPitchValue ? 0f : player.GetAxisRaw(17))));
			val.Emit(OpCodes.Stloc_S, (byte)7);
			int index2 = val.Index;
			val.GotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCall(x, typeof(CameraModePlayerBasic), "PerformAimAssist")
			});
			val.Index -= 3;
			val.RemoveRange(4);
			val.GotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdflda(x, typeof(CameraInfo), "previousCameraState")
			});
			val.Index -= 5;
			int index3 = val.Index;
			val.Emit(OpCodes.Ldarg_3);
			val.Emit(OpCodes.Ldloc_S, (byte)6);
			val.Emit(OpCodes.Ldloc_S, (byte)7);
			val.EmitDelegate<Func<Vector2, Vector2, Vector2>>((Func<Vector2, Vector2, Vector2>)delegate(Vector2 mouseVector, Vector2 joystickVector)
			{
				//IL_0014: 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_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				wasTurningLeft = isTurningLeft;
				wasTurningRight = isTurningRight;
				isTurningLeft = joystickVector.x < -0.8f;
				isTurningRight = joystickVector.x > 0.8f;
				if (!ModConfig.MotionControlsEnabled)
				{
					isTurningLeft = isTurningLeft || mouseVector.x < -0.8f;
					isTurningRight = isTurningRight || mouseVector.x > 0.8f;
				}
				Vector2 zero = Vector2.zero;
				if (justTurnedLeft)
				{
					zero.x = -ModConfig.SnapTurnAngle.Value;
				}
				else if (justTurnedRight)
				{
					zero.x = ModConfig.SnapTurnAngle.Value;
				}
				if ((isTurningLeft || isTurningRight) && timeSinceLastSnapTurn <= ModConfig.SnapTurnHoldDelay.Value)
				{
					timeSinceLastSnapTurn += Time.deltaTime;
				}
				else
				{
					timeSinceLastSnapTurn = 0f;
				}
				return zero;
			});
			val.Emit(OpCodes.Stfld, typeof(CollectLookInputResult).GetField("lookInput"));
			IEnumerable<ILLabel> incomingLabels = il.GetIncomingLabels(val.Next);
			val.RemoveRange(24);
			foreach (ILLabel item in incomingLabels)
			{
				item.Target = val.Next;
			}
			ILLabel val2 = val.MarkLabel();
			val.Index = index3;
			val.Emit(OpCodes.Br_S, (object)val2);
			ILLabel val3 = val.MarkLabel();
			val.Index = index2;
			val.EmitDelegate<Func<bool>>((Func<bool>)(() => ModConfig.SnapTurn.Value));
			val.Emit(OpCodes.Brtrue_S, (object)val3);
		}

		private static void SetBodyInvisible(orig_Update orig, Run self)
		{
			CharacterBody localBody = Utils.localBody;
			if (Object.op_Implicit((Object)(object)localBody))
			{
				ModelLocator modelLocator = localBody.modelLocator;
				object obj;
				if (modelLocator == null)
				{
					obj = null;
				}
				else
				{
					Transform modelTransform = modelLocator.modelTransform;
					obj = ((modelTransform != null) ? ((Component)modelTransform).gameObject.GetComponentsInChildren<Renderer>() : null);
				}
				Renderer[] array = (Renderer[])obj;
				if (forcedVisibleRenderers != null)
				{
					string currentBodyName = ((Object)localBody).name.Substring(0, ((Object)localBody).name.IndexOf("(Clone)"));
					ForcedVisibleRenderer[] visibleBodyRenderers = forcedVisibleRenderers.Where((ForcedVisibleRenderer x) => x.bodyName == currentBodyName).ToArray();
					array = array.Where((Renderer x) => !Array.Exists(visibleBodyRenderers, (ForcedVisibleRenderer vren) => vren.rendererObjectName == ((Object)((Component)x).gameObject).name)).ToArray();
				}
				if (array != null)
				{
					Renderer[] array2 = array;
					foreach (Renderer val in array2)
					{
						if (((Component)val).gameObject.activeSelf)
						{
							((Component)val).gameObject.SetActive(false);
						}
					}
				}
			}
			orig.Invoke(self);
		}

		private static void SetCameraStateOverride(orig_SetCameraState orig, CameraRigController self, CameraState cameraState)
		{
			//IL_047f: 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_021d: Invalid comparison between Unknown and I4
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Invalid comparison between Unknown and I4
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_041f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0420: Unknown result type (might be due to invalid IL or missing references)
			//IL_0434: Unknown result type (might be due to invalid IL or missing references)
			//IL_0435: Unknown result type (might be due to invalid IL or missing references)
			//IL_0444: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_040b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: 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_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)Run.instance))
			{
				if (self.cameraMode is CameraModePlayerBasic && ModConfig.InitialFirstPersonValue)
				{
					if (!Object.op_Implicit((Object)(object)VRCameraWrapper.instance))
					{
						VRCameraWrapper.instance = new GameObject("VR Camera Rig").AddComponent<VRCameraWrapper>();
						VRCameraWrapper.instance.Init(self);
					}
					if (!self.cameraMode.IsSpectating(self) && self.cameraModeContext.targetInfo.isViewerControlled && Object.op_Implicit((Object)(object)self.targetBody))
					{
						VRCameraWrapper.instance.UpdateRotation(cameraState);
						cameraState.rotation = ((Component)self.sceneCam).transform.rotation;
					}
					if (self.targetBody.IsLocalBody())
					{
						if (!Object.op_Implicit((Object)(object)cachedCameraTargetTransform))
						{
							if (!ModConfig.InitialRoomscaleValue)
							{
								ChildLocator component = ((Component)self.targetBody.modelLocator.modelTransform).GetComponent<ChildLocator>();
								if (Object.op_Implicit((Object)(object)component))
								{
									cachedCameraTargetTransform = component.FindChild("VRCamera");
								}
							}
							if (!Object.op_Implicit((Object)(object)cachedCameraTargetTransform))
							{
								cachedCameraTargetTransform = new GameObject("VRCamera").transform;
								cachedCameraTargetTransform.SetParent(self.targetBody.transform);
								cachedCameraTargetTransform.localPosition = Vector3.zero;
								cachedCameraTargetTransform.localRotation = Quaternion.identity;
								CapsuleCollider component2 = ((Component)self.targetBody).GetComponent<CapsuleCollider>();
								if (Object.op_Implicit((Object)(object)component2))
								{
									cachedCameraTargetTransform.Translate(component2.center + new Vector3(0f, (0f - component2.height) / 2f + ModConfig.HeightMultiplier.Value * component2.height, 0f), (Space)1);
									((Component)VRCameraWrapper.instance).transform.localScale = Vector3.one * ModConfig.HeightMultiplier.Value * (component2.height / 1.82f);
								}
							}
						}
						((Component)VRCameraWrapper.instance).transform.position = (self.hasOverride ? cameraState.position : cachedCameraTargetTransform.position);
					}
				}
				if (!self.targetBody.IsLocalBody() && ((int)SceneCatalog.mostRecentSceneDef.sceneType == 1 || (int)SceneCatalog.mostRecentSceneDef.sceneType == 2) && Run.instance.livingPlayerCount > 0)
				{
					if (!Object.op_Implicit((Object)(object)spectatorCamera))
					{
						Camera main = Camera.main;
						bool enabled = ((Behaviour)main).enabled;
						if (enabled)
						{
							((Behaviour)main).enabled = false;
						}
						bool activeSelf = ((Component)main).gameObject.activeSelf;
						if (activeSelf)
						{
							((Component)main).gameObject.SetActive(false);
						}
						spectatorCamera = Object.Instantiate<GameObject>(((Component)main).gameObject, (Transform)null);
						Component[] components = spectatorCamera.GetComponents<Component>();
						foreach (Component val in components)
						{
							if (!(val is Transform) && !(val is Camera) && !(val is PostProcessLayer) && (!(val is SobelCommandBuffer) || val is DecaliciousRenderer))
							{
								Object.Destroy((Object)(object)val);
							}
						}
						spectatorCameraComponent = spectatorCamera.GetComponent<Camera>();
						spectatorCameraComponent.stereoTargetEye = (StereoTargetEyeMask)0;
						spectatorCameraComponent.targetTexture = spectatorCameraPrefab.GetComponent<Camera>().targetTexture;
						if (activeSelf != ((Component)main).gameObject.activeSelf)
						{
							((Component)main).gameObject.SetActive(activeSelf);
						}
						if (enabled != ((Behaviour)main).enabled)
						{
							((Behaviour)main).enabled = enabled;
						}
						spectatorCamera.SetActive(true);
						((Behaviour)spectatorCameraComponent).enabled = true;
						XRDevice.DisableAutoXRCameraTracking(spectatorCameraComponent, true);
					}
					if (!Object.op_Implicit((Object)(object)spectatorScreen))
					{
						spectatorScreen = Object.Instantiate<GameObject>(spectatorScreenPrefab, (Transform)null);
						spectatorScreen.SetLayerRecursive(LayerIndex.ui.intVal);
						spectatorScreen.transform.rotation = Quaternion.Euler(new Vector3(0f, ((Component)self.uiCam).transform.eulerAngles.y, 0f));
						spectatorScreen.transform.position = ((Component)self.uiCam).transform.position + spectatorScreen.transform.forward * 2f;
					}
					spectatorCamera.transform.position = cameraState.position;
					spectatorCamera.transform.rotation = cameraState.rotation;
					spectatorCameraComponent.fieldOfView = cameraState.fov;
				}
				else
				{
					if (Object.op_Implicit((Object)(object)spectatorCamera))
					{
						Object.Destroy((Object)(object)spectatorCamera);
					}
					if (Object.op_Implicit((Object)(object)spectatorScreen))
					{
						Object.Destroy((Object)(object)spectatorScreen);
					}
				}
			}
			orig.Invoke(self, cameraState);
		}

		private static void RemoveFOVChange(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			ILCursor val = new ILCursor(il);
			val.GotoNext(new Func<Instruction, bool>[2]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 1),
				(Instruction x) => ILPatternMatchingExt.MatchLdfld<CameraState>(x, "fov")
			});
			val.Index -= 6;
			val.RemoveRange(9);
		}

		private static Ray GetVRCrosshairRaycastRay(orig_GetCrosshairRaycastRay orig, CameraModePlayerBasic self, ref CameraModeContext context, Vector2 crosshairOffset, Vector3 raycastStartPlanePoint, ref CameraState cameraState)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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)
			if (MotionControls.HandsReady)
			{
				return MotionControls.GetHandByDominance(dominant: true).aimRay;
			}
			Camera sceneCam = context.cameraInfo.sceneCam;
			if (!Object.op_Implicit((Object)(object)sceneCam))
			{
				return default(Ray);
			}
			float fieldOfView = sceneCam.fieldOfView;
			float num = fieldOfView * sceneCam.aspect;
			Quaternion val = Quaternion.Euler(crosshairOffset.y * fieldOfView, crosshairOffset.x * num, 0f);
			val = ((Component)sceneCam).transform.rotation * val;
			return new Ray(Vector3.ProjectOnPlane(((Component)sceneCam).transform.position - raycastStartPlanePoint, ((Component)sceneCam).transform.rotation * Vector3.forward) + raycastStartPlanePoint, val * Vector3.forward);
		}
	}
	public class ConfortVignette : MonoBehaviour
	{
		private static Material vignette;

		private const float INITIAL_RADIUS = 0.7f;

		private const float TARGET_RADIUS = 0.4f;

		private const float RADIUS_CHANGE_PER_SECOND = 3f;

		private static float currentRadius = 0.7f;

		private static float currentTargetRadius = 0.7f;

		private static bool activated;

		private static bool wasActivated;

		private List<EntityStateMachine> stateMachines;

		private bool foundStateMachine;

		private static List<Type> vignetteAbilities = new List<Type>
		{
			typeof(DodgeState),
			typeof(SlideState),
			typeof(BlinkState),
			typeof(MiniBlinkState),
			typeof(ToolbotDash),
			typeof(FlyUpState),
			typeof(Assaulter2),
			typeof(EvisDash),
			typeof(FocusedAssaultDash),
			typeof(EvisDash),
			typeof(SwingChargedFist),
			typeof(SwingZapFist),
			typeof(GroundSlam),
			typeof(Leap),
			typeof(ChainableLeap)
		};

		internal static ConfortVignette instance { get; private set; }

		private void Awake()
		{
			instance = this;
			if (!Object.op_Implicit((Object)(object)vignette))
			{
				vignette = VRMod.VRAssetBundle.LoadAsset<Material>("VignetteMaterial");
			}
		}

		private void OnEnable()
		{
			if (!foundStateMachine)
			{
				RoR2Application.onUpdate += FindStateMachine;
			}
		}

		private void OnDisable()
		{
			if (!foundStateMachine)
			{
				RoR2Application.onUpdate -= FindStateMachine;
			}
		}

		public static void AddVignetteState(Type stateType)
		{
			if (!stateType.IsSubclassOf(typeof(EntityState)))
			{
				VRMod.StaticLogger.LogError((object)("The type " + stateType.ToString() + " doesn't inherit from EntityState and cannot be added as a vignette state."));
			}
			else if (vignetteAbilities.Contains(stateType))
			{
				VRMod.StaticLogger.LogError((object)("The state type " + stateType.ToString() + " is already set as a vignette state and cannot be added twice."));
			}
			else
			{
				vignetteAbilities.Add(stateType);
			}
		}

		private void FindStateMachine()
		{
			CharacterBody cachedBody = LocalUserManager.GetFirstLocalUser().cachedBody;
			if (Object.op_Implicit((Object)(object)cachedBody))
			{
				stateMachines = ((Component)cachedBody).GetComponents<EntityStateMachine>().ToList();
				foundStateMachine = true;
				RoR2Application.onUpdate -= FindStateMachine;
			}
		}

		private void OnRenderImage(RenderTexture source, RenderTexture destination)
		{
			if (foundStateMachine)
			{
				stateMachines.RemoveAll((EntityStateMachine sm) => (Object)(object)sm == (Object)null);
				activated = stateMachines != null && stateMachines.Count > 0 && stateMachines.Exists((EntityStateMachine sm) => vignetteAbilities.Contains(((object)sm.state).GetType()));
				if (activated != wasActivated)
				{
					wasActivated = activated;
					currentTargetRadius = (activated ? 0.4f : 0.7f);
				}
				if (currentRadius != currentTargetRadius)
				{
					float num = Mathf.Abs(currentTargetRadius - currentRadius);
					float num2 = Mathf.Clamp(Time.deltaTime * ((currentRadius < currentTargetRadius) ? 3f : (-3f)), 0f - num, num);
					currentRadius += num2;
					vignette.SetFloat("_VRadius", currentRadius);
				}
			}
			Graphics.Blit((Texture)(object)source, destination, vignette);
		}
	}
	internal static class RecenterController
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__Recenter;
		}

		private static GameObject instance;

		private static bool loggedRecenter;

		private static float appliedOffsetDeg;

		private static Transform offsetTarget;

		private static Quaternion offsetTargetBaseRotation;

		public static void Init()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			instance = new GameObject("VRManager");
			instance.AddComponent<MPEventSystemProvider>().fallBackToMainEventSystem = true;
			InputResponse val = instance.AddComponent<InputResponse>();
			val.inputActionNames = new string[1] { "RecenterHMD" };
			val.onPress = new UnityEvent();
			UnityEvent onPress = val.onPress;
			object obj = <>O.<0>__Recenter;
			if (obj == null)
			{
				UnityAction val2 = Recenter;
				<>O.<0>__Recenter = val2;
				obj = (object)val2;
			}
			onPress.AddListener((UnityAction)obj);
			Object.DontDestroyOnLoad((Object)(object)instance);
		}

		private static void Recenter()
		{
			RecenterNow();
		}

		internal static void RecenterNow()
		{
			List<XRInputSubsystem> list = new List<XRInputSubsystem>();
			SubsystemManager.GetInstances<XRInputSubsystem>(list);
			int num = 0;
			foreach (XRInputSubsystem item in list)
			{
				if (item.TryRecenter())
				{
					num++;
				}
			}
			bool flag = false;
			float newOffsetDeg = 0f;
			if (!Object.op_Implicit((Object)(object)Run.instance))
			{
				flag = TryManualYawRecenter(out newOffsetDeg);
			}
			if (!loggedRecenter)
			{
				loggedRecenter = true;
				VRMod.StaticLogger.LogInfo((object)$"[VR input] Recenter triggered. {list.Count} input subsystem(s), {num} accepted TryRecenter(); manual menu recenter applied={flag} (offset now {newOffsetDeg:F1} deg). (Only logged once.)");
			}
		}

		private static bool TryManualYawRecenter(out float newOffsetDeg)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			newOffsetDeg = appliedOffsetDeg;
			Camera main = Camera.main;
			if (!Object.op_Implicit((Object)(object)main) || !Object.op_Implicit((Object)(object)((Component)main).transform.parent))
			{
				return false;
			}
			Transform parent = ((Component)main).transform.parent;
			if ((Object)(object)offsetTarget != (Object)(object)parent)
			{
				offsetTarget = parent;
				offsetTargetBaseRotation = parent.rotation;
				appliedOffsetDeg = 0f;
			}
			float num = ((Component)main).transform.localEulerAngles.y;
			if (num > 180f)
			{
				num -= 360f;
			}
			appliedOffsetDeg = 0f - num;
			parent.rotation = Quaternion.AngleAxis(appliedOffsetDeg, Vector3.up) * offsetTargetBaseRotation;
			newOffsetDeg = appliedOffsetDeg;
			return true;
		}
	}
	internal class StereoProjectionFix : MonoBehaviour
	{
		private Camera ParentCamera;

		private Camera _childCamera;

		private GameObject _childCameraObject;

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

		private void Start()
		{
			CreateChildCamera();
		}

		private void OnEnable()
		{
			if (Object.op_Implicit((Object)(object)_childCamera))
			{
				((Behaviour)_childCamera).enabled = true;
			}
		}

		private void OnDisable()
		{
			if (Object.op_Implicit((Object)(object)_childCamera))
			{
				((Behaviour)_childCamera).enabled = false;
			}
			if (Object.op_Implicit((Object)(object)ParentCamera))
			{
				ParentCamera.ResetProjectionMatrix();
			}
		}

		private void CreateChildCamera()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0040: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)_childCameraObject))
			{
				_childCameraObject = new GameObject("VR Stereo Reference Camera");
				_childCameraObject.transform.SetParent(((Component)this).transform, false);
				_childCameraObject.transform.localPosition = Vector3.zero;
				_childCameraObject.transform.localRotation = Quaternion.identity;
				_childCameraObject.transform.localScale = Vector3.one;
				_childCamera = _childCameraObject.AddComponent<Camera>();
				_childCamera.CopyFrom(ParentCamera);
				_childCamera.cullingMask = 0;
				_childCamera.clearFlags = (CameraClearFlags)4;
				_childCamera.depth = -100f;
				_childCamera.allowHDR = false;
				_childCamera.allowMSAA = false;
				_childCamera.useOcclusionCulling = false;
				_childCamera.stereoTargetEye = (StereoTargetEyeMask)3;
				_childCamera.targetTexture = null;
				((Behaviour)_childCamera).enabled = true;
				TrackedPoseDriver obj = _childCameraObject.AddComponent<TrackedPoseDriver>();
				obj.SetPoseSource((DeviceType)0, (TrackedPose)3);
				obj.trackingType = (TrackingType)0;
				obj.updateType = (UpdateType)0;
			}
		}

		private void LateUpdate()
		{
			if (Object.op_Implicit((Object)(object)_childCamera) && Object.op_Implicit((Object)(object)ParentCamera))
			{
				if (_childCamera.nearClipPlane != ParentCamera.nearClipPlane)
				{
					_childCamera.nearClipPlane = ParentCamera.nearClipPlane;
				}
				if (_childCamera.farClipPlane != ParentCamera.farClipPlane)
				{
					_childCamera.farClipPlane = ParentCamera.farClipPlane;
				}
			}
		}

		private void OnPreCull()
		{
			ApplyStereoProjection();
		}

		private void OnPreRender()
		{
			ApplyStereoProjection();
		}

		private void ApplyStereoProjection()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_003a: Invalid comparison between Unknown and I4
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)ParentCamera) || !Object.op_Implicit((Object)(object)_childCamera) || !XRSettings.enabled || !XRSettings.isDeviceActive)
			{
				return;
			}
			MonoOrStereoscopicEye stereoActiveEye = ParentCamera.stereoActiveEye;
			StereoscopicEye val;
			if ((int)stereoActiveEye != 0)
			{
				if ((int)stereoActiveEye != 1)
				{
					return;
				}
				val = (StereoscopicEye)1;
			}
			else
			{
				val = (StereoscopicEye)0;
			}
			ParentCamera.projectionMatrix = _childCamera.GetStereoProjectionMatrix(val);
			ParentCamera.SetStereoProjectionMatrix((StereoscopicEye)0, _childCamera.GetStereoProjectionMatrix((StereoscopicEye)0));
			ParentCamera.SetStereoProjectionMatrix((StereoscopicEye)1, _childCamera.GetStereoProjectionMatrix((StereoscopicEye)1));
		}

		private void OnDestroy()
		{
			if (Object.op_Implicit((Object)(object)ParentCamera))
			{
				ParentCamera.ResetProjectionMatrix();
			}
			if (Object.op_Implicit((Object)(object)_childCameraObject))
			{
				Object.Destroy((Object)(object)_childCameraObject);
			}
		}
	}
	internal class VRCameraWrapper : MonoBehaviour
	{
		public static VRCameraWrapper instance;

		internal CameraRigController cameraRigController { get; private set; }

		public void Init(CameraRigController cameraRigController)
		{
			//IL_0034: 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)
			instance = this;
			this.cameraRigController = cameraRigController;
			while (((Component)cameraRigController).transform.childCount > 0)
			{
				Transform child = ((Component)cameraRigController).transform.GetChild(((Component)cameraRigController).transform.childCount - 1);
				child.SetParent(((Component)this).transform);
				child.localPosition = Vector3.zero;
				child.localRotation = Quaternion.identity;
			}
			if (Object.op_Implicit((Object)(object)CameraFixes.liv))
			{
				CameraFixes.liv.stage = ((Component)this).transform;
			}
			XROrigin obj = ((Component)this).gameObject.AddComponent<XROrigin>();
			obj.Origin = ((Component)this).gameObject;
			obj.RequestedTrackingOriginMode = (TrackingOriginMode)1;
		}

		internal void UpdateRotation(CameraState cameraState)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.rotation = cameraState.rotation;
		}
	}
	internal static class ActionAddons
	{
		internal struct ActionDef
		{
			internal int id;

			internal string actionName;

			internal string token;

			internal InputActionType actionType;

			internal bool hasPosAndNeg;

			internal KeyboardKeyCode keyboardMap;

			internal ControllerInput joystickMap;
		}

		internal enum ControllerInput
		{
			LeftStickX,
			LeftStickY,
			RightStickX,
			RightStickY,
			LeftTrigger,
			RightTrigger,
			A,
			B,
			X,
			Y,
			LeftBumper,
			RightBumper,
			Back,
			Start,
			LeftStickButton,
			RightStickButton,
			DPadUp,
			DPadRight,
			DPadDown,
			DPadLeft,
			LeftStick,
			RightStick,
			Guide,
			None
		}

		internal enum MouseInput
		{
			Horizontal,
			Vertical,
			ScrollWheel,
			LeftMouseButton,
			RightMouseButton,
			MiddleMouseButton
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static Action<Action<UserData>, UserData> <0>__AddCustomActions;

			public static hook_LoadUserProfiles <1>__AddBindingsToLoadedProfiles;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_LoadDefaultProfile <>9__3_0;

			internal void <Init>b__3_0(orig_LoadDefaultProfile orig)
			{
				orig.Invoke();
				AddMissingBindingsToProfile(UserProfile.defaultProfile);
			}
		}

		internal static readonly ActionDef[] actionDefs = new ActionDef[1]
		{
			new ActionDef
			{
				id = 150,
				actionName = "RecenterHMD",
				token = "ACTION_RECENTER",
				actionType = (InputActionType)1,
				hasPosAndNeg = false,
				joystickMap = ControllerInput.DPadUp,
				keyboardMap = (KeyboardKeyCode)305
			}
		};

		private static ActionElementMap[] joystickActionElementMaps;

		private static ActionElementMap[] keyboardActionElementMaps;

		internal static void Init()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			GenerateMapsFromActionDefs();
			ActionDef[] array = actionDefs;
			for (int i = 0; i < array.Length; i++)
			{
				ActionDef actionDef = array[i];
				InputCatalog.actionToToken.Add(new ActionAxisPair(actionDef.actionName, (AxisRange)0), actionDef.token);
				if (actionDef.hasPosAndNeg)
				{
					InputCatalog.actionToToken.Add(new ActionAxisPair(actionDef.actionName, (AxisRange)1), actionDef.token + "_POSITIVE");
					InputCatalog.actionToToken.Add(new ActionAxisPair(actionDef.actionName, (AxisRange)2), actionDef.token + "_NEGATIVE");
				}
			}
			new Hook((MethodBase)typeof(UserData).GetMethod("gLOOAxUFAvrvUufkVjaYyZoeLbLE", BindingFlags.Instance | BindingFlags.NonPublic), (Delegate)new Action<Action<UserData>, UserData>(AddCustomActions));
			object obj = <>O.<1>__AddBindingsToLoadedProfiles;
			if (obj == null)
			{
				hook_LoadUserProfiles val = AddBindingsToLoadedProfiles;
				<>O.<1>__AddBindingsToLoadedProfiles = val;
				obj = (object)val;
			}
			SaveSystem.LoadUserProfiles += (hook_LoadUserProfiles)obj;
			object obj2 = <>c.<>9__3_0;
			if (obj2 == null)
			{
				hook_LoadDefaultProfile val2 = delegate(orig_LoadDefaultProfile orig)
				{
					orig.Invoke();
					AddMissingBindingsToProfile(UserProfile.defaultProfile);
				};
				<>c.<>9__3_0 = val2;
				obj2 = (object)val2;
			}
			UserProfile.LoadDefaultProfile += (hook_LoadDefaultProfile)obj2;
		}

		private static void GenerateMapsFromActionDefs()
		{
			//IL_004c: 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_0042: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			List<ActionElementMap> list = new List<ActionElementMap>();
			List<ActionElementMap> list2 = new List<ActionElementMap>();
			ActionDef[] array = actionDefs;
			for (int i = 0; i < array.Length; i++)
			{
				ActionDef actionDef = array[i];
				if (actionDef.joystickMap != ControllerInput.None)
				{
					ActionElementMap item = new ActionElementMap(actionDef.id, (ControllerElementType)1, (int)actionDef.joystickMap, (Pole)0, (AxisRange)0);
					list.Add(item);
				}
				if ((int)actionDef.keyboardMap != 0)
				{
					ActionElementMap val = new ActionElementMap(actionDef.id, (ControllerElementType)1, -1);
					val.keyboardKeyCode = actionDef.keyboardMap;
					list2.Add(val);
				}
			}
			joystickActionElementMaps = list.ToArray();
			keyboardActionElementMaps = list2.ToArray();
		}

		private static void AddBindingsToLoadedProfiles(orig_LoadUserProfiles orig, SaveSystem self)
		{
			orig.Invoke(self);
			foreach (UserProfile item in self.loadedUserProfiles.Values.ToList())
			{
				if (AddMissingBindingsToProfile(item))
				{
					self.RequestSave(item, false);
				}
			}
		}

		private static bool AddMissingBindingsToProfile(UserProfile profile)
		{
			bool result = false;
			ActionElementMap[] array = joystickActionElementMaps;
			foreach (ActionElementMap map in array)
			{
				if (!((ControllerMap)profile.joystickMap).GetElementMaps().ToList().Exists((ActionElementMap x) => x.actionId == map.actionId))
				{
					((ControllerMap)profile.joystickMap).BakeElementMap(map);
					((ControllerMapWithAxes)profile.joystickMap).YIHWTDQSbIqJbYOqOkQhWAtbyqVF(map);
					result = true;
				}
			}
			array = keyboardActionElementMaps;
			foreach (ActionElementMap map2 in array)
			{
				if (!((ControllerMap)profile.keyboardMap).GetElementMaps().ToList().Exists((ActionElementMap x) => x.actionId == map2.actionId))
				{
					((ControllerMap)profile.keyboardMap).BakeElementMap(map2);
					((ControllerMap)profile.keyboardMap).NldBMnbsNdlFSDEGKYoPsQLMTgldb(map2);
					result = true;
				}
			}
			return result;
		}

		private static void AddCustomActions(Action<UserData> orig, UserData self)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			ActionDef[] array = actionDefs;
			for (int i = 0; i < array.Length; i++)
			{
				ActionDef actionDef = array[i];
				InputAction val = new InputAction();
				val.QurFqcdYtHIEpCpYBddZfQQtnImHA(actionDef.id);
				val.LEWtVuPGPZtPpCUSAMYCEbPqyAuf(actionDef.actionName);
				val.nLGCfekdjaMIxCLlcjdYgcEjEDxz(actionDef.actionType);
				val.nfWwbfSEwQCdVSicPaIBIPkMqJfu(actionDef.actionName);
				if (actionDef.hasPosAndNeg)
				{
					val.GAHtgIDPCORanWTLICacRjOgVnIB(actionDef.actionName + "Positive");
					val.XUmfoFggZhnhpRdQofcqWKcCrFlB(actionDef.actionName + "Negative");
				}
				val.MFwTFVDRoziRWNJMARlSUXIebtLw(0);
				val.BSFQAxJApIZsVFnOmINQEGShHPvFb(true);
				val.REsRGcKFtjbUwlqUSreCTUubayPb(0);
				self.actions?.Add(val);
			}
			ControllerMap_Editor val2 = self.joystickMaps?[0];
			ControllerMap_Editor val3 = self.keyboardMaps?[0];
			if (val2 != null && val3 != null)
			{
				array = actionDefs;
				for (int i = 0; i < array.Length; i++)
				{
					ActionDef actionDef2 = array[i];
					if (!val2.actionElementMaps.Exists((ActionElementMap x) => x.actionId == actionDef2.id))
					{
						ActionElementMap[] array2 = joystickActionElementMaps;
						foreach (ActionElementMap item in array2)
						{
							val2.actionElementMaps.Add(item);
						}
					}
					if (!val3.actionElementMaps.Exists((ActionElementMap x) => x.actionId == actionDef2.id))
					{
						ActionElementMap[] array2 = keyboardActionElementMaps;
						foreach (ActionElementMap item2 in array2)
						{
							val2.actionElementMaps.Add(item2);
						}
					}
				}
			}
			orig(self);
		}
	}
	internal static class ControllerGlyphs
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_GetGlyphString_MPEventSystem_string_AxisRange_InputSource_bool <0>__GetCustomGlyphString;

			public static hook_Awake <1>__ApplyInputDisplaySpriteAsset;

			public static hook_Awake <2>__ApplyContextSpriteAsset;

			public static hook_OnLastActiveControllerChanged <3>__ChangedToCustom;

			public static Action <4>__FindControllerType;
		}

		internal static readonly string[] standardGlyphs = new string[33]
		{
			"<sprite name=\"texVRGlyphs_LStick\">", "<sprite name=\"texVRGlyphs_LStick\">", "<sprite name=\"texVRGlyphs_RStick\">", "<sprite name=\"texVRGlyphs_RStick\">", "<sprite name=\"texVRGlyphs_LStick\">", "<sprite name=\"texVRGlyphs_LStick\">", "<sprite name=\"texVRGlyphs_RPrimary\">", "<sprite name=\"texVRGlyphs_RSecondary\">", "<sprite name=\"texVRGlyphs_RTrigger\">", "<sprite name=\"texVRGlyphs_LTrigger\">",
			"<sprite name=\"texVRGlyphs_LGrip\">", "<sprite name=\"texVRGlyphs_RGrip\">", "<sprite name=\"texVRGlyphs_LPrimary\">", "<sprite name=\"texVRGlyphs_LStickPress\">", "<sprite name=\"texVRGlyphs_RStickPress\">", "<sprite name=\"texVRGlyphs_LSecondaryHold\">", "<sprite name=\"texVRGlyphs_LSecondaryHold\">", "<sprite name=\"texVRGlyphs_RPrimary\">", "<sprite name=\"texVRGlyphs_RSecondary\">", "<sprite name=\"texVRGlyphs_LPrimary\">",
			"<sprite name=\"texVRGlyphs_LTrigger\">", "<sprite name=\"texVRGlyphs_RTrigger\">", "<sprite name=\"texVRGlyphs_LGrip\">", "<sprite name=\"texVRGlyphs_RGrip\">", "<sprite name=\"texVRGlyphs_LSecondary\">", "<sprite name=\"texVRGlyphs_RStickPress\">", "<sprite name=\"texVRGlyphs_Unknown\">", "<sprite name=\"texVRGlyphs_Unknown\">", "<sprite name=\"texVRGlyphs_Unknown\">", "<sprite name=\"texVRGlyphs_Unknown\">",
			"<sprite name=\"texVRGlyphs_Unknown\">", "<sprite name=\"texVRGlyphs_Unknown\">", "<sprite name=\"texVRGlyphs_LSecondary\">"
		};

		internal static readonly string[] viveGlyphs = new string[33]
		{
			"<sprite name=\"texVRGlyphs_LTouch\">", "<sprite name=\"texVRGlyphs_LTouch\">", "<sprite name=\"texVRGlyphs_RTouchHor\">", "<sprite name=\"texVRGlyphs_RTouchHor\">", "<sprite name=\"texVRGlyphs_LTouch\">", "<sprite name=\"texVRGlyphs_LTouch\">", "<sprite name=\"texVRGlyphs_RTouchDown\">", "<sprite name=\"texVRGlyphs_RTouchUp\">", "<sprite name=\"texVRGlyphs_RTrigger\">", "<sprite name=\"texVRGlyphs_LTrigger\">",
			"<sprite name=\"texVRGlyphs_LGrip\">", "<sprite name=\"texVRGlyphs_RGrip\">", "<sprite name=\"texVRGlyphs_LTouchPress2\">", "<sprite name=\"texVRGlyphs_LTouchPress\">", "<sprite name=\"texVRGlyphs_RMenu\">", "<sprite name=\"texVRGlyphs_LMenuHold\">", "<sprite name=\"texVRGlyphs_LMenuHold\">", "<sprite name=\"texVRGlyphs_RTouchDown\">", "<sprite name=\"texVRGlyphs_RTouchUp\">", "<sprite name=\"texVRGlyphs_LTouchPress2\">",
			"<sprite name=\"texVRGlyphs_LTrigger\">", "<sprite name=\"texVRGlyphs_RTrigger\">", "<sprite name=\"texVRGlyphs_LGrip\">", "<sprite name=\"texVRGlyphs_RGrip\">", "<sprite name=\"texVRGlyphs_LMenu\">", "<sprite name=\"texVRGlyphs_RMenu\">", "<sprite name=\"texVRGlyphs_Unknown\">", "<sprite name=\"texVRGlyphs_Unknown\">", "<sprite name=\"texVRGlyphs_Unknown\">", "<sprite name=\"texVRGlyphs_Unknown\">",
			"<sprite name=\"texVRGlyphs_Unknown\">", "<sprite name=\"texVRGlyphs_Unknown\">", "<sprite name=\"texVRGlyphs_LMenu\">"
		};

		internal static readonly string[] wmrGlyphs = new string[33]
		{
			"<sprite name=\"texVRGlyphs_LTouch\">", "<sprite name=\"texVRGlyphs_LTouch\">", "<sprite name=\"texVRGlyphs_RStick\">", "<sprite name=\"texVRGlyphs_RStick\">", "<sprite name=\"texVRGlyphs_LStick\">", "<sprite name=\"texVRGlyphs_LStick\">", "<sprite name=\"texVRGlyphs_RTouchDown\">", "<sprite name=\"texVRGlyphs_RTouchUp\">", "<sprite name=\"texVRGlyphs_RTrigger\">", "<sprite name=\"texVRGlyphs_LTrigger\">",
			"<sprite name=\"texVRGlyphs_LGrip\">", "<sprite name=\"texVRGlyphs_RGrip\">", "<sprite name=\"texVRGlyphs_LTouchPress2\">", "<sprite name=\"texVRGlyphs_LTouchPress\">", "<sprite name=\"texVRGlyphs_RMenu\">", "<sprite name=\"texVRGlyphs_LMenuHold\">", "<sprite name=\"texVRGlyphs_LMenuHold\">", "<sprite name=\"texVRGlyphs_RTouchDown\">", "<sprite name=\"texVRGlyphs_RTouchUp\">", "<sprite name=\"texVRGlyphs_LTouchPress2\">",
			"<sprite name=\"texVRGlyphs_LTrigger\">", "<sprite name=\"texVRGlyphs_RTrigger\">", "<sprite name=\"texVRGlyphs_LGrip\">", "<sprite name=\"texVRGlyphs_RGrip\">", "<sprite name=\"texVRGlyphs_LMenu\">", "<sprite name=\"texVRGlyphs_RMenu\">", "<sprite name=\"texVRGlyphs_Unknown\">", "<sprite name=\"texVRGlyphs_Unknown\">", "<sprite name=\"texVRGlyphs_Unknown\">", "<sprite name=\"texVRGlyphs_Unknown\">",
			"<sprite name=\"texVRGlyphs_Unknown\">", "<sprite name=\"texVRGlyphs_Unknown\">", "<sprite name=\"texVRGlyphs_LMenu\">"
		};

		private static TMP_SpriteAsset glyphsSpriteAsset;

		private static string[] currentGlyphs;

		private static bool isUsingMotionControls;

		internal static void Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//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_005b: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			object obj = <>O.<0>__GetCustomGlyphString;
			if (obj == null)
			{
				hook_GetGlyphString_MPEventSystem_string_AxisRange_InputSource_bool val = GetCustomGlyphString;
				<>O.<0>__GetCustomGlyphString = val;
				obj = (object)val;
			}
			Glyphs.GetGlyphString_MPEventSystem_string_AxisRange_InputSource_bool += (hook_GetGlyphString_MPEventSystem_string_AxisRange_InputSource_bool)obj;
			object obj2 = <>O.<1>__ApplyInputDisplaySpriteAsset;
			if (obj2 == null)
			{
				hook_Awake val2 = ApplyInputDisplaySpriteAsset;
				<>O.<1>__ApplyInputDisplaySpriteAsset = val2;
				obj2 = (object)val2;
			}
			InputBindingDisplayController.Awake += (hook_Awake)obj2;
			object obj3 = <>O.<2>__ApplyContextSpriteAsset;
			if (obj3 == null)
			{
				hook_Awake val3 = ApplyContextSpriteAsset;
				<>O.<2>__ApplyContextSpriteAsset = val3;
				obj3 = (object)val3;
			}
			ContextManager.Awake += (hook_Awake)obj3;
			object obj4 = <>O.<3>__ChangedToCustom;
			if (obj4 == null)
			{
				hook_OnLastActiveControllerChanged val4 = ChangedToCustom;
				<>O.<3>__ChangedToCustom = val4;
				obj4 = (object)val4;
			}
			MPEventSystem.OnLastActiveControllerChanged += (hook_OnLastActiveControllerChanged)obj4;
			glyphsSpriteAsset = VRMod.VRAssetBundle.LoadAsset<TMP_SpriteAsset>("sprVRGlyphs");
			RoR2Application.onUpdate += FindControllerType;
		}

		private static void FindControllerType()
		{
			//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)
			InputDevice deviceAtXRNode = InputDevices.GetDeviceAtXRNode((XRNode)5);
			if (((InputDevice)(ref deviceAtXRNode)).name == null)
			{
				return;
			}
			string text = ((InputDevice)(ref deviceAtXRNode)).name.ToLower();
			if (!(text == ""))
			{
				if (text.Contains("htc vive controller"))
				{
					currentGlyphs = viveGlyphs;
				}
				else if (text.Contains("windows mr controller"))
				{
					currentGlyphs = wmrGlyphs;
				}
				else
				{
					currentGlyphs = standardGlyphs;
				}
				RoR2Application.onUpdate -= FindControllerType;
			}
		}

		private static string GetCustomGlyphString(orig_GetGlyphString_MPEventSystem_string_AxisRange_InputSource_bool orig, MPEventSystem eventSystem, string actionName, AxisRange axisRange, InputSource currentInputSource, bool useLastActiveControllerOnly)
		{
			//IL_0083: 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)
			if (!Object.op_Implicit((Object)(object)eventSystem))
			{
				return "???";
			}
			if (isUsingMotionControls)
			{
				Glyphs.resultsList.Clear();
				eventSystem.player.controllers.maps.GetElementMapsWithAction((ControllerType)20, Controllers.ControllerID, actionName, false, Glyphs.resultsList);
				if (Glyphs.resultsList.Count() > 0)
				{
					ActionElementMap val = Glyphs.resultsList.First();
					if (val.elementIdentifierId > 0 && val.elementIdentifierId < currentGlyphs.Length)
					{
						return currentGlyphs[val.elementIdentifierId];
					}
				}
			}
			return orig.Invoke(eventSystem, actionName, axisRange, currentInputSource, useLastActiveControllerOnly);
		}

		private static void ChangedToCustom(orig_OnLastActiveControllerChanged orig, MPEventSystem self, Player player, Controller controller)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			if (controller != null && (int)controller.type == 20)
			{
				isUsingMotionControls = true;
				self.currentInputSource = (InputSource)1;
			}
			else
			{
				isUsingMotionControls = false;
				orig.Invoke(self, player, controller);
			}
		}

		private static void ApplyContextSpriteAsset(orig_Awake orig, ContextManager self)
		{
			orig.Invoke(self);
			if (Object.op_Implicit((Object)(object)self.glyphTMP) && Object.op_Implicit((Object)(object)glyphsSpriteAsset))
			{
				ApplySpriteAsset(self.glyphTMP);
			}
		}

		private static void ApplyInputDisplaySpriteAsset(orig_Awake orig, InputBindingDisplayController self)
		{
			orig.Invoke(self);
			if (Object.op_Implicit((Object)(object)glyphsSpriteAsset))
			{
				if (Object.op_Implicit((Object)(object)self.guiLabel))
				{
					ApplySpriteAsset(self.guiLabel);
				}
				if (Object.op_Implicit((Object)(object)self.label))
				{
					ApplySpriteAsset(self.label);
				}
			}
		}

		internal static void ApplySpriteAsset(TextMeshPro tmp)
		{
			((TMP_Text)tmp).spriteAsset = glyphsSpriteAsset;
		}

		internal static void ApplySpriteAsset(TextMeshProUGUI tmp)
		{
			((TMP_Text)tmp).spriteAsset = glyphsSpriteAsset;
		}

		internal static string GetGlyph(uint index)
		{
			if (currentGlyphs == null || index >= currentGlyphs.Length)
			{
				return "";
			}
			return currentGlyphs[index];
		}
	}
	public class Controllers
	{
		public struct SkillBindingOverride
		{
			public string bodyName;

			public SkillSlot dominantTrigger;

			public SkillSlot nonDominantTrigger;

			public SkillSlot nonDominantGrip;

			public SkillSlot dominantGrip;

			public SkillBindingOverride(string bodyName, SkillSlot dominantTrigger, SkillSlot nonDominantTrigger, SkillSlot nonDominantGrip, SkillSlot dominantGrip)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				this.bodyName = bodyName;
				this.dominantTrigger = dominantTrigger;
				this.nonDominantTrigger = nonDominantTrigger;
				this.nonDominantGrip = nonDominantGrip;
				this.dominantGrip = dominantGrip;
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static Action<Action<InputManager, int, string>, InputManager, int, string> <0>__DisableInputManager;

			public static Action <1>__UpdateVRInputs;

			public static Action <2>__Update;

			public static hook_Awake <3>__DisableControllerBinds;

			public static hook_Update <4>__VRHaptics;

			public static Manipulator <5>__ControllerMovementDirection;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_SetMainProfile <>9__18_0;

			public static Func<Instruction, bool> <>9__26_0;

			public static Func<Transform, Transform> <>9__26_1;

			public static Func<Instruction, bool> <>9__26_2;

			public static Func<Vector2, Vector2> <>9__26_3;

			public static Func<Instruction, bool> <>9__26_4;

			public static Func<Vector3, Vector3> <>9__26_5;

			internal void <Init>b__18_0(orig_SetMainProfile orig, ProfileMainMenuScreen self, UserProfile profile)
			{
				orig.Invoke(self, profile);
				if (initializedLocalUser)
				{
					initializedLocalUser = false;
					RoR2Application.onUpdate += Update;
				}
			}

			internal bool <ControllerMovementDirection>b__26_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchStloc(x, 6);
			}

			internal Transform <ControllerMovementDirection>b__26_1(Transform headTransform)
			{
				if (!ModConfig.ControllerMovementDirection.Value)
				{
					return headTransform;
				}
				if (MotionControls.HandsReady)
				{
					return ((Component)MotionControls.GetHandByDominance(dominant: false).muzzle).transform;
				}
				return headTransform;
			}

			internal bool <ControllerMovementDirection>b__26_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdloca(x, 8);
			}

			internal Vector2 <ControllerMovementDirection>b__26_3(Vector2 vector)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				if (!ModConfig.ControllerMovementDirection.Value || MotionControls.HandsReady)
				{
					return vector;
				}
				Quaternion localRotation = InputTracking.GetLocalRotation((XRNode)4);
				Quaternion localRotation2 = ((Component)Camera.main).transform.localRotation;
				float num = ((Quaternion)(ref localRotation2)).eulerAngles.y - ((Quaternion)(ref localRotation)).eulerAngles.y;
				return Vector2.op_Implicit(Quaternion.Euler(new Vector3(0f, 0f, num)) * Vector2.op_Implicit(vector));
			}

			internal bool <ControllerMovementDirection>b__26_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallvirt<Transform>(x, "get_right");
			}

			internal Vector3 <ControllerMovementDirection>b__26_5(Vector3 vector)
			{
				//IL_0013: 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_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: 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)
				if (!ModConfig.ControllerMovementDirection.Value || !MotionControls.HandsReady)
				{
					return vector;
				}
				Vector3 val = Vector3.ProjectOnPlane(vector, Vector3.up);
				return ((Vector3)(ref val)).normalized * ((Vector3)(ref vector)).magnitude;
			}
		}

		private static CustomController vrControllers;

		private static CustomControllerMap vrGameplayMap;

		private static CustomControllerMap vrUIMap;

		private static bool initializedMainPlayer;

		private static bool initializedLocalUser;

		private static List<SkillBindingOverride> skillBindingOverrides = new List<SkillBindingOverride>
		{
			new SkillBindingOverride("LoaderBody", (SkillSlot)0, (SkillSlot)1, (SkillSlot)3, (SkillSlot)2),
			new SkillBindingOverride("RailgunnerBody", (SkillSlot)0, (SkillSlot)2, (SkillSlot)3, (SkillSlot)1)
		};

		private static BaseInput[] inputs;

		private static List<BaseInput> modInputs = new List<BaseInput>();

		private static bool autoSprintHeldHigh;

		private static float lastAutoSprintPulse;

		internal static int leftJoystickID { get; private set; }

		internal static int rightJoystickID { get; private set; }

		internal static int ControllerID => ((Controller)vrControllers).id;

		internal static void Init()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Expected O, but got Unknown
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Expected O, but got Unknown
			try
			{
				MethodInfo method = typeof(InputManager).GetMethod("OnNativeDeviceDiscovered", BindingFlags.Instance | BindingFlags.NonPublic);
				if (method != null)
				{
					new Hook((MethodBase)method, (Delegate)new Action<Action<InputManager, int, string>, InputManager, int, string>(DisableInputManager));
				}
				else
				{
					VRMod.StaticLogger.LogWarning((object)"[VR input] InputManager.OnNativeDeviceDiscovered not found; skipping the native-device suppression hook.");
				}
			}
			catch (Exception ex)
			{
				VRMod.StaticLogger.LogWarning((object)("[VR input] Failed to hook InputManager.OnNativeDeviceDiscovered (continuing anyway): " + ex.Message));
			}
			VRInputDiagnostics.LogInteractionProfiles("Controllers.Init");
			VRInputDiagnostics.DumpDevices("Controllers.Init");
			ReInput.InputSourceUpdateEvent += UpdateVRInputs;
			RoR2Application.onUpdate += Update;
			object obj = <>O.<3>__DisableControllerBinds;
			if (obj == null)
			{
				hook_Awake val = DisableControllerBinds;
				<>O.<3>__DisableControllerBinds = val;
				obj = (object)val;
			}
			InputBindingControl.Awake += (hook_Awake)obj;
			object obj2 = <>O.<4>__VRHaptics;
			if (obj2 == null)
			{
				hook_Update val2 = VRHaptics;
				<>O.<4>__VRHaptics = val2;
				obj2 = (object)val2;
			}
			GamepadVibrationManager.Update += (hook_Update)obj2;
			object obj3 = <>O.<5>__ControllerMovementDirection;
			if (obj3 == null)
			{
				Manipulator val3 = ControllerMovementDirection;
				<>O.<5>__ControllerMovementDirection = val3;
				obj3 = (object)val3;
			}
			PlayerCharacterMasterController.Update += (Manipulator)obj3;
			object obj4 = <>c.<>9__18_0;
			if (obj4 == null)
			{
				hook_SetMainProfile val4 = delegate(orig_SetMainProfile orig, ProfileMainMenuScreen self, UserProfile profile)
				{
					orig.Invoke(self, profile);
					if (initializedLocalUser)
					{
						initializedLocalUser = false;
						RoR2Application.onUpdate += Update;
					}
				};
				<>c.<>9__18_0 = val4;
				obj4 = (object)val4;
			}
			ProfileMainMenuScreen.SetMainProfile += (hook_SetMainProfile)obj4;
			SetupControllerInputs();
		}

		private static void DisableInputManager(Action<InputManager, int, string> orig, InputManager self, int deviceId, string deviceDescriptor)
		{
		}

		private static void VRHaptics(orig_Update orig)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Invalid comparison between Unknown and I4
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke();
			if (Utils.localUserProfile != null && !((Object)(object)Utils.localCameraRig == (Object)null) && Utils.localInputPlayer != null && Utils.localInputPlayer.controllers.GetLastActiveController() != null && (int)Utils.localInputPlayer.controllers.GetLastActiveController().type == 20)
			{
				VibrationContext val = new VibrationContext
				{
					localUser = LocalUserManager.GetFirstLocalUser(),
					cameraRigController = Utils.localCameraRig,
					userVibrationScale = Utils.localUserProfile.gamepadVibrationScale
				};
				float num = ((VibrationContext)(ref val)).CalcCamDisplacementMagnitude() * val.userVibrationScale;
				InputDevice deviceAtXRNode = InputDevices.GetDeviceAtXRNode((XRNode)4);
				InputDevice deviceAtXRNode2 = InputDevices.GetDeviceAtXRNode((XRNode)5);
				HapticCapabilities val2 = default(HapticCapabilities);
				if (((InputDevice)(ref deviceAtXRNode)).TryGetHapticCapabilities(ref val2) && ((HapticCapabilities)(ref val2)).supportsImpulse)
				{
					((InputDevice)(ref deviceAtXRNode)).SendHapticImpulse(0u, num, Time.deltaTime);
				}
				if (((InputDevice)(ref deviceAtXRNode2)).TryGetHapticCapabilities(ref val2) && ((HapticCapabilities)(ref val2)).supportsImpulse)
				{
					((InputDevice)(ref deviceAtXRNode2)).SendHapticImpulse(0u, num, Time.deltaTime);
				}
			}
		}

		[Obsolete("Deprecated. Use AddSkillBindingOverride instead.")]
		public static void AddSkillRemap(string bodyName, SkillSlot skill1, SkillSlot skill2)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Invalid comparison between Unknown and I4
			//IL_0056: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected I4, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected I4, but got Unknown
			if (skillBindingOverrides.Exists((SkillBindingOverride x) => x.bodyName == bodyName))
			{
				throw new ArgumentException("VR Mod: Cannot add multiple skill binding overrides on the same body.");
			}
			if ((int)skill1 == -1 || (int)skill2 == -1)
			{
				throw new ArgumentException("VR Mod: Cannot override a skill binding with None.");
			}
			SkillSlot[] array = new SkillSlot[4];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			SkillSlot[] array2 = (SkillSlot[])(object)array;
			int num = Array.IndexOf(array2, skill1);
			int num2 = Array.IndexOf(array2, skill2);
			array2[num] = (SkillSlot)(int)skill2;
			array2[num2] = (SkillSlot)(int)skill1;
			AddSkillBindingOverride(bodyName, array2[0], array2[1], array2[2], array2[3]);
		}

		public static void AddSkillBindingOverride(string bodyName, SkillSlot dominantTrigger, SkillSlot nonDominantTrigger, SkillSlot nonDominantGrip, SkillSlot dominantGrip)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Invalid comparison between Unknown and I4
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Invalid comparison between Unknown and I4
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_0057: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			if (skillBindingOverrides.Exists((SkillBindingOverride x) => x.bodyName == bodyName))
			{
				throw new ArgumentException("VR Mod: Cannot add multiple skill binding overrides on the same body.");
			}
			if ((int)dominantTrigger == -1 || (int)nonDominantTrigger == -1 || (int)nonDominantGrip == -1 || (int)dominantGrip == -1)
			{
				throw new ArgumentException("VR Mod: Cannot override a skill binding with None.");
			}
			skillBindingOverrides.Add(new SkillBindingOverride(bodyName, dominantTrigger, nonDominantTrigger, nonDominantGrip, dominantGrip));
		}

		internal static void ApplyRemaps(string bodyName)
		{
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Expected I4, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected I4, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Expected I4, but got Unknown
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Expected I4, but got Unknown
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			if (!skillBindingOverrides.Exists((SkillBindingOverride x) => x.bodyName == bodyName))
			{
				VRMod.StaticLogger.LogInfo((object)$"No binding overrides found for '{bodyName}'. Using default binding.");
				RevertRemap();
				return;
			}
			VRMod.StaticLogger.LogInfo((object)$"Binding overrides were found for '{bodyName}'. Applying overrides.");
			SkillBindingOverride skillBindingOverride = skillBindingOverrides.FirstOrDefault((SkillBindingOverride x) => x.bodyName == bodyName);
			if (!(skillBindingOverride.bodyName == bodyName))
			{
				return;
			}
			int[] array = new int[4]
			{
				ModConfig.LeftDominantHand.Value ? 9 : 8,
				ModConfig.LeftDominantHand.Value ? 8 : 9,
				ModConfig.LeftDominantHand.Value ? 11 : 10,
				ModConfig.LeftDominantHand.Value ? 10 : 11
			};
			ActionElementMap[] array2 = (ActionElementMap[])(object)new ActionElementMap[4]
			{
				((ControllerMap)vrGameplayMap).GetElementMapsWithAction(7 + skillBindingOverride.dominantTrigger)[0],
				((ControllerMap)vrGameplayMap).GetElementMapsWithAction(7 + skillBindingOverride.nonDominantTrigger)[0],
				((ControllerMap)vrGameplayMap).GetElementMapsWithAction(7 + skillBindingOverride.nonDominantGrip)[0],
				((ControllerMap)vrGameplayMap).GetElementMapsWithAction(7 + skillBindingOverride.dominantGrip)[0]
			};
			ControllerMap map = Utils.localInputPlayer.controllers.maps.GetMap((Controller)(object)vrControllers, ((ControllerMap)vrGameplayMap).id);
			for (int num = 0; num < 4; num++)
			{
				ActionElementMap val = array2[num];
				if (val.elementIdentifierId != array[num] && !map.ReplaceElementMap(val.id, val.actionId, val.axisContribution, array[num], val.elementType, val.axisRange, val.invert))
				{
					VRMod.StaticLogger.LogError((object)"An error occured while trying to override skill bindings.");
				}
			}
		}

		internal static void RevertRemap()
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			ControllerMap map = Utils.localInputPlayer.controllers.maps.GetMap((Controller)(object)vrControllers, ((ControllerMap)vrGameplayMap).id);
			int[] array = new int[4]
			{
				ModConfig.LeftDominantHand.Value ? 9 : 8,
				ModConfig.LeftDominantHand.Value ? 8 : 9,
				ModConfig.LeftDominantHand.Value ? 11 : 10,
				ModConfig.LeftDominantHand.Value ? 10 : 11
			};
			for (int i = 0; i < 4; i++)
			{
				ActionElementMap val = ((ControllerMap)vrGameplayMap).GetElementMapsWithAction(7 + i)[0];
				if (val.elementIdentifierId != array[i] && !map.ReplaceElementMap(val.id, val.actionId, val.axisContribution, array[i], val.elementType, val.axisRange, val.invert))
				{
					VRMod.StaticLogger.LogError((object)"An error occured while trying to revert skill binding overrides.");
				}
			}
		}

		internal static void ChangeDominanceDependantMaps()
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			Player localInputPlayer = Utils.localInputPlayer;
			for (int i = 7; i < 11; i++)
			{
				ActionElementMap val = ((ControllerMap)vrGameplayMap).GetElementMapsWithAction(i)[0];
				int num = val.elementIdentifierId;
				switch (num)
				{
				case 8:
					num = 9;
					break;
				case 9:
					num = 8;
					break;
				case 10:
					num = 11;
					break;
				case 11:
					num = 10;
					break;
				}
				if (!localInputPlayer.controllers.maps.GetMap((Controller)(object)vrControllers, ((ControllerMap)vrGameplayMap).id).ReplaceElementMap(val.id, val.actionId, val.axisContribution, num, val.elementType, val.axisRange, val.invert))
				{
					VRMod.StaticLogger.LogError((object)"Failed to remap");
					break;
				}
			}
		}

		private static void ControllerMovementDirection(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.GotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchStloc(x, 6)
			});
			val.EmitDelegate<Func<Transform, Transform>>((Func<Transform, Transform>)delegate(Transform headTransform)
			{
				if (!ModConfig.ControllerMovementDirection.Value)
				{
					return headTransform;
				}
				return MotionControls.HandsReady ? ((Component)MotionControls.GetHandByDominance(dominant: false).muzzle).transform : headTransform;
			});
			val.GotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdloca(x, 8)
			});
			val.Emit(OpCodes.Ldloc_S, (byte)7);
			val.EmitDelegate<Func<Vector2, Vector2>>((Func<Vector2, Vector2>)delegate(Vector2 vector)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				if (!ModConfig.ControllerMovementDirection.Value || MotionControls.HandsReady)
				{
					return vector;
				}
				Quaternion localRotation = InputTracking.GetLocalRotation((XRNode)4);
				Quaternion localRotation2 = ((Component)Camera.main).transform.localRotation;
				float num = ((Quaternion)(ref localRotation2)).eulerAngles.y - ((Quaternion)(ref localRotation)).eulerAngles.y;
				return Vector2.op_Implicit(Quaternion.Euler(new Vector3(0f, 0f, num)) * Vector2.op_Implicit(vector));
			});
			val.Emit(OpCodes.Stloc_S, (byte)7);
			val.GotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallvirt<Transform>(x, "get_right")
			});
			val.Index += 1;
			val.EmitDelegate<Func<Vector3, Vector3>>((Func<Vector3, Vector3>)delegate(Vector3 vector)
			{
				//IL_0013: 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_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: 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)
				if (!ModConfig.ControllerMovementDirection.Value || !MotionControls.HandsReady)
				{
					return vector;
				}
				Vector3 val2 = Vector3.ProjectOnPlane(vector, Vector3.up);
				return ((Vector3)(ref val2)).normalized * ((Vector3)(ref vector)).magnitude;
			});
		}

		private static void DisableControllerBinds(orig_Awake orig, InputBindingControl self)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			orig.Invoke(self);
			if (ModConfig.InitialMotionControlsValue && (int)self.inputSource == 1 && Object.op_Implicit((Object)(object)self.button))
			{
				((Selectable)self.button).interactable = false;
				self.button = null;
			}
		}

		private static void SetupControllerInputs()
		{
			vrControllers = RewiredAddons.CreateRewiredController();
			vrUIMap = RewiredAddons.CreateUIMap(((Controller)vrControllers).id);
			vrGameplayMap = RewiredAddons.CreateGameplayMap(((Controller)vrControllers).id);
			inputs = new BaseInput[21]
			{
				new VectorInput((XRNode)4, InputHelpers.Axis2D.PrimaryAxis2D, 0, 1),
				new VectorInput((XRNode)5, InputHelpers.Axis2D.PrimaryAxis2D, 2, 3),
				new VectorInput((XRNode)4, InputHelpers.Axis2D.PrimaryAxis2D, 4, 5),
				new ButtonInput((XRNode)5, InputHelpers.Button.PrimaryButton, 6),
				new ButtonInput((XRNode)5, InputHelpers.Button.SecondaryButton, 7),
				new ButtonInput((XRNode)5, InputHelpers.Button.TriggerButton, 8),
				new ButtonInput((XRNode)4, InputHelpers.Button.TriggerButton, 9),
				new ButtonInput((XRNode)4, InputHelpers.Button.GripButton, 10),
				new ButtonInput((XRNode)5, InputHelpers.Button.GripButton, 11),
				new ButtonInput((XRNode)4, InputHelpers.Button.PrimaryButton, 12),
				new ButtonInput((XRNode)4, InputHelpers.Button.Primary2DAxisClick, 13),
				new ButtonInput((XRNode)5, InputHelpers.Button.Primary2DAxisClick, 14),
				new HoldableButtonInput((XRNode)4, InputHelpers.Button.SecondaryButton, 15),
				new ButtonInput((XRNode)5, InputHelpers.Button.PrimaryButton, 17),
				new ButtonInput((XRNode)5, InputHelpers.Button.SecondaryButton, 18),
				new ButtonInput((XRNode)4, InputHelpers.Button.PrimaryButton, 19),
				new ButtonInput((XRNode)4, InputHelpers.Button.TriggerButton, 20),
				new ButtonInput((XRNode)5, InputHelpers.Button.TriggerButton, 21),
				new ButtonInput((XRNode)4, InputHelpers.Button.GripButton, 22),
				new ButtonInput((XRNode)5, InputHelpers.Button.GripButton, 23),
				new ButtonInput((XRNode)4, InputHelpers.Button.SecondaryButton, 24)
			};
		}

		private static void Update()
		{
			if (!initializedMainPlayer && AddVRController(LocalUserManager.GetRewiredMainPlayer()))
			{
				initializedMainPlayer = true;
			}
			LocalUser firstLocalUser = LocalUserManager.GetFirstLocalUser();
			if (firstLocalUser != null && AddVRController(firstLocalUser.inputPlayer))
			{
				initializedLocalUser = true;
				RoR2Application.onUpdate -= Update;
			}
		}

		internal static bool AddVRController(Player inputPlayer)
		{
			if (!inputPlayer.controllers.ContainsController((Controller)(object)vrControllers))
			{
				inputPlayer.controllers.AddController((Controller)(object)vrControllers, false);
				((Controller)vrControllers).enabled = true;
				VRInputDiagnostics.OnControllerAddedToPlayer(inputPlayer.name);
			}
			if (inputPlayer.controllers.maps.GetAllMaps((ControllerType)20).ToList().Count < 2)
			{
				if (inputPlayer.controllers.maps.GetMap((ControllerType)20, ((Controller)vrControllers).id, 2, 0) == null)
				{
					inputPlayer.controllers.maps.AddMap((Controller)(object)vrControllers, (ControllerMap)(object)vrUIMap);
				}
				if (inputPlayer.controllers.maps.GetMap((ControllerType)20, ((Controller)vrControllers).id, 0, 0) == null)
				{
					inputPlayer.controllers.maps.AddMap((Controller)(object)vrControllers, (ControllerMap)(object)vrGameplayMap);
				}
				if (!((ControllerMap)vrGameplayMap).enabled)
				{
					((ControllerMap)vrGameplayMap).enabled = true;
				}
				if (!((ControllerMap)vrUIMap).enabled)
				{
					((ControllerMap)vrUIMap).enabled = true;
				}
			}
			if (inputPlayer.controllers.ContainsController((Controller)(object)vrControllers))
			{
				return inputPlayer.controllers.maps.GetAllMaps((ControllerType)20).ToList().Count >= 2;
			}
			return false;
		}

		private static void UpdateVRInputs()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			bool isInLobby = LobbyNavigation.IsInLobby;
			BaseInput[] array = inputs;
			foreach (BaseInput baseInput in array)
			{
				if (!isInLobby || !(baseInput is ButtonInput buttonInput) || (buttonInput.ElementId != 24 && buttonInput.ElementId != 15))
				{
					baseInput.UpdateValues(vrControllers);
				}
			}
			foreach (BaseInput modInput in modInputs)
			{
				modInput.UpdateValues(vrControllers);
			}
			if (isInLobby)
			{
				InputDevice deviceAtXRNode = InputDevices.GetDeviceAtXRNode((XRNode)4);
				bool isPressed = default(bool);
				if (((InputDevice)(ref deviceAtXRNode)).isValid && deviceAtXRNode.IsPressed(InputHelpers.Button.SecondaryButton, out isPressed) && isPressed)
				{
					vrControllers.SetButtonValueById(32, true);
				}
				else
				{
					vrControllers.SetButtonValueById(32, false);
				}
			}
			ApplyAutoSprint();
			LobbyNavigation.Poll();
			SettingsTabs.Poll();
			VRInputDiagnostics.Tick(inputs);
		}

		private static void ApplyAutoSprint()
		{
			//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_0033: Unknown result type (might be due to invalid IL or missing references)
			if (!ModConfig.AutoSprint.Value || vrControllers == null || !Object.op_Implicit((Object)(object)Run.instance))
			{
				return;
			}
			InputDevice deviceAtXRNode = InputDevices.GetDeviceAtXRNode((XRNode)4);
			Vector2 val = default(Vector2);
			if (((InputDevice)(ref deviceAtXRNode)).isValid && ((InputDevice)(ref deviceAtXRNode)).TryGetFeatureValue(CommonUsages.primary2DAxis, ref val))
			{
				bool num = ((Vector2)(ref val)).sqrMagnitude > 0.04f;
				CharacterBody localBody = Utils.localBody;
				if (!num || !Object.op_Implicit((Object)(object)localBody))
				{
					autoSprintHeldHigh = false;
				}
				else if (IsAnySkillButtonHeld())
				{
					autoSprintHeldHigh = false;
				}
				else if (IsFlier())
				{
					vrControllers.SetButtonValueById(13, true);
				}
				else if (localBody.isSprinting)
				{
					autoSprintHeldHigh = false;
				}
				else if (autoSprintHeldHigh)
				{
					autoSprintHeldHigh = false;
				}
				else if (!(Time.unscaledTime - lastAutoSprintPulse < 0.15f))
				{
					lastAutoSprintPulse = Time.unscaledTime;
					autoSprintHeldHigh = true;
					vrControllers.SetButtonValueById(13, true);
				}
			}
		}

		private static bool IsAnySkillButtonHeld()
		{
			//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_0008: 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_0017: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				InputDevice deviceAtXRNode = InputDevices.GetDeviceAtXRNode((XRNode)4);
				InputDevice deviceAtXRNode2 = InputDevices.GetDeviceAtXRNode((XRNode)5);
				bool isPressed = default(bool);
				if (((InputDevice)(ref deviceAtXRNode2)).isValid && deviceAtXRNode2.IsPressed(InputHelpers.Button.TriggerButton, out isPressed) && isPressed)
				{
					return true;
				}
				if (((InputDevice)(ref deviceAtXRNode)).isValid && deviceAtXRNode.IsPressed(InputHelpers.Button.TriggerButton, out isPressed) && isPressed)
				{
					return true;
				}
				if (((InputDevice)(ref deviceAtXRNode)).isValid && deviceAtXRNode.IsPressed(InputHelpers.Button.GripButton, out isPressed) && isPressed)
				{
					return true;
				}
				if (((InputDevice)(ref deviceAtXRNode2)).isValid && deviceAtXRNode2.IsPressed(InputHelpers.Button.GripButton, out isPressed) && isPressed)
				{
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		private static bool IsFlier()
		{
			try
			{
				LocalUser firstLocalUser = LocalUserManager.GetFirstLocalUser();
				PlayerCharacterMasterController val = ((firstLocalUser != null) ? firstLocalUser.cachedMasterController : null);
				return Object.op_Implicit((Object)(object)val) && val.bodyIsFlier;
			}
			catch
			{
				return false;
			}
		}
	}
	internal static class LobbyNavigation
	{
		private struct Entry
		{
			public Selectable selectable;

			public Vector2 pos;

			public bool rightSide;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_OnEnable <>9__10_0;

			public static hook_OnDisable <>9__10_1;

			public static hook_Update <>9__10_2;

			internal void <Init>b__10_0(orig_OnEnable orig, CharacterSelectController self)
			{
				orig.Invoke(self);
				activeLobby = self;
				nextSweepFrame = 0;
				lastFixedCount = -1;
				dumpedLayout = false;
				dumpedBigLayout = false;
				lastSelected = null;
				tracedSelection = false;
			}

			internal void <Init>b__10_1(orig_OnDisable orig, CharacterSelectController self)
			{
				orig.Invoke(self);
				if ((Object)(object)activeLobby == (Object)(object)self)
				{
					activeLobby = null;
				}
			}

			internal void <Init>b__10_2(orig_Update orig, MPEventSystem self)
			{
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//IL_0148: Unknown result type (might be due to invalid IL or missing references)
				//IL_014d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0127: Unknown result type (might be due to invalid IL or missing references)
				//IL_012c: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self);
				if (!IsInLobby)
				{
					return;
				}
				try
				{
					GameObject currentSelectedGameObject = ((EventSystem)self).currentSelectedGameObject;
					if ((Object)(object)currentSelectedGameObject == (Object)(object)lastSelected)
					{
						return;
					}
					if ((Object)(object)lastSelected == (Object)null && Time.frameCount - lastSelectedFrame < 2)
					{
						lastSelected = currentSelectedGameObject;
						lastSelectedFrame = Time.frameCount;
						return;
					}
					lastSelected = currentSelectedGameObject;
					lastSelectedFrame = Time.frameCount;
					if ((Object)(object)currentSelectedGameObject == (Object)null)
					{
						VRMod.StaticLogger.LogInfo((object)"[VR input] Lobby select: <none> (deselected).");
						return;
					}
					Selectable component = currentSelectedGameObject.GetComponent<Selectable>();
					Transform val = ((!Object.op_Implicit((Object)(object)activeLobby)) ? null : (Object.op_Implicit((Object)(object)((Component)activeLobby).GetComponentInParent<Canvas>()) ? ((Component)((Component)activeLobby).GetComponentInParent<Canvas>().rootCanvas).transform : null));
					string text = ((Object)currentSelectedGameObject).name;
					Transform parent = currentSelectedGameObject.transform.parent;
					int num = 0;
					while ((Object)(object)parent != (Object)null && (Object)(object)parent != (Object)(object)val && num < 6)
					{
						text = ((Object)parent).name + "/" + text;
						parent = parent.parent;
						num++;
					}
					Vector3 val2;
					string text2;
					if (!Object.op_Implicit((Object)(object)val))
					{
						val2 = currentSelectedGameObject.transform.position;
						text2 = ((Vector3)(ref val2)).ToString("F2");
					}
					else
					{
						val2 = val.InverseTransformPoint(currentSelectedGameObject.transform.position);
						text2 = ((Vector3)(ref val2)).ToString("F0");
					}
					string text3 = text2;
					string text4 = (Object.op_Implicit((Object)(object)currentSelectedGameObject.GetComponentInParent<SurvivorIconController>()) ? "GRID" : "    ");
					string text5 = (Object.op_Implicit((Object)(object)component) ? $"interactable={component.IsInteractable()}" : "not-a-Selectable");
					VRMod.StaticLogger.LogInfo((object)("[VR input] Lobby select: [" + text4 + "] '" + text + "' local=" + text3 + " " + text5));
					tracedSelection = true;
				}
				catch (Exception ex)
				{
					VRMod.StaticLogger.LogWarning((object)("[VR input] Lobby select trace failed: " + ex.Message));
				}
			}
		}

		private static CharacterSelectController activeLobby;

		private static int nextSweepFrame;

		private static int lastFixedCount;

		private static bool dumpedLayout;

		private static bool dumpedBigLayout;

		private static GameObject lastSelected;

		private static int lastSelectedFrame;

		private static bool tracedSelection;

		internal static bool IsInLobby
		{
			get
			{
				if ((Object)(object)activeLobby != (Object)null)
				{
					return ((Behaviour)activeLobby).isActiveAndEnabled;
				}
				return false;
			}
		}

		internal static void Init()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//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_0043: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			object obj = <>c.<>9__10_0;
			if (obj == null)
			{
				hook_OnEnable val = delegate(orig_OnEnable orig, CharacterSelectController self)
				{
					orig.Invoke(self);
					activeLobby = self;
					nextSweepFrame = 0;
					lastFixedCount = -1;
					dumpedLayout = false;
					dumpedBigLayout = false;
					lastSelected = null;
					tracedSelection = false;
				};
				<>c.<>9__10_0 = val;
				obj = (object)val;
			}
			CharacterSelectController.OnEnable += (hook_OnEnable)obj;
			object obj2 = <>c.<>9__10_1;
			if (obj2 == null)
			{
				hook_OnDisable val2 = delegate(orig_OnDisable orig, CharacterSelectController self)
				{
					orig.Invoke(self);
					if ((Object)(object)activeLobby == (Object)(object)self)
					{
						activeLobby = null;
					}
				};
				<>c.<>9__10_1 = val2;
				obj2 = (object)val2;
			}
			CharacterSelectController.OnDisable += (hook_OnDisable)obj2;
			object obj3 = <>c.<>9__10_2;
			if (obj3 == null)
			{
				hook_Update val3 = delegate(orig_Update orig, MPEventSystem self)
				{
					//IL_0143: Unknown result type (might be due to invalid IL or missing references)
					//IL_0148: Unknown result type (might be due to invalid IL or missing references)
					//IL_014d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0127: Unknown result type (might be due to invalid IL or missing references)
					//IL_012c: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self);
					if (!IsInLobby)
					{
						return;
					}
					try
					{
						GameObject currentSelectedGameObject = ((EventSystem)self).currentSelectedGameObject;
						if (!((Object)(object)currentSelectedGameObject == (Object)(object)lastSelected))
						{
							if ((Object)(object)lastSelected == (Object)null && Time.frameCount - lastSelectedFrame < 2)
							{
								lastSelected = currentSelectedGameObject;
								lastSelectedFrame = Time.frameCount;
							}
							else
							{
								lastSelected = currentSelectedGameObject;
								lastSelectedFrame = Time.frameCount;
								if ((Object)(object)currentSelectedGameObject == (Object)null)
								{
									VRMod.StaticLogger.LogInfo((object)"[VR input] Lobby select: <none> (deselected).");
								}
								else
								{
									Selectable component = currentSelectedGameObject.GetComponent<Selectable>();
									Transform val4 = ((!Object.op_Implicit((Object)(object)activeLobby)) ? null : (Object.op_Implicit((Object)(object)((Component)activeLobby).GetComponentInParent<Canvas>()) ? ((Component)((Component)activeLobby).GetComponentInParent<Canvas>().rootCanvas).transform : null));
									string text = ((Object)currentSelectedGameObject).name;
									Transform parent = currentSelectedGameObject.transform.parent;
									int num = 0;
									while ((Object)(object)parent != (Object)null && (Object)(object)parent != (Object)(object)val4 && num < 6)
									{
										text = ((Object)parent).name + "/" + text;
										parent = parent.parent;
										num++;
									}
									Vector3 val5;
									string text2;
									if (!Object.op_Implicit((Object)(object)val4))
									{
										val5 = currentSelectedGameObject.transform.position;
										text2 = ((Vector3)(ref val5)).ToString("F2");
									}
									else
									{
										val5 = val4.InverseTransformPoint(currentSelectedGameObject.transform.position);
										text2 = ((Vector3)(ref val5)).ToString("F0");
									}
									string text3 = text2;
									string text4 = (Object.op_Implicit((Object)(object)currentSelectedGameObject.GetComponentInParent<SurvivorIconController>()) ? "GRID" : "    ");
									string text5 = (Object.op_Implicit((Object)(object)component) ? $"interactable={component.IsInteractable()}" : "not-a-Selectable");
									VRMod.StaticLogger.LogInfo((object)("[VR input] Lobby select: [" + text4 + "] '" + text + "' local=" + text3 + " " + text5));
									tracedSelection = true;
								}
							}
						}
					}
					catch (Exception ex)
					{
						VRMod.StaticLogger.LogWarning((object)("[VR input] Lobby select trace failed: " + ex.Message));
					}
				};
				<>c.<>9__10_2 = val3;
				obj3 = (object)val3;
			}
			MPEventSystem.Update += (hook_Update)obj3;
		}

		internal static void Poll()
		{
			CharacterSelectController val = activeLobby;
			if (!Object.op_Implicit((Object)(object)val) || !((Behaviour)val).isActiveAndEnabled || Time.frameCount < nextSweepFrame)
			{
				return;
			}
			nextSweepFrame = Time.frameCount + 15;
			try
			{
				MakeNavigable(val);
			}
			catch (Exception ex)
			{
				VRMod.StaticLogger.LogWarning((object)("[VR input] Lobby navigation upkeep failed: " + ex.Message));
			}
		}

		private static bool InsideFrustum(Plane[] frustum, Vector3 worldPos)
		{
			//IL_0008: 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_0010: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < frustum.Length; i++)
			{
				Plane val = frustum[i];
				if (((Plane)(ref val)).GetDistanceToPoint(worldPos) < -0.5f)
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsExcluded(Selectable selectable, Transform canvasRoot)
		{
			Transform val = ((Component)selectable).transform;
			while ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)canvasRoot)
			{
				string name = ((Object)val).name;
				if (name.IndexOf("footer", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("ready", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("lobbycontrolpanel", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("chatbox", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("miscpanel", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
				val = val.parent;
			}
			return false;
		}

		private static Selectable FindNeighbor(List<Entry> entries, int self, Vector2 direction)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0059: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			Selectable result = null;
			float num = float.MaxValue;
			Vector2 pos = entries[self].pos;
			bool rightSide = entries[self].rightSide;
			for (int i = 0; i < entries.Count; i++)
			{
				if (i == self || entries[i].rightSide != rightSide)
				{
					continue;
				}
				Vector2 val = entries[i].pos - pos;
				float num2 = Vector2.Dot(val, direction);
				if (!(num2 < 1f))
				{
					float num3 = Mathf.Abs(val.x * direction.y) + Mathf.Abs(val.y * direction.x);
					float num4 = num2 + 2f * num3;
					if (num4 < num)
					{
						num = num4;
						result = entries[i].selectable;
					}
				}
			}
			return result;
		}

		private static void MakeNavigable(CharacterSelectController lobby)
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_0387: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ce: 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_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: 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_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0474: Unknown result type (might be due to invalid IL or missing references)
			//IL_048c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0554: Unknown result type (might be due to invalid IL or missing references)
			//IL_0584: Unknown result type (might be due to invalid IL or missing references)
			Canvas componentInParent = ((Component)lobby).GetComponentInParent<Canvas>();
			Transform val = (Object.op_Implicit((Object)(object)componentInParent) ? ((Component)componentInParent.rootCanvas).transform : ((Component)lobby).transform);
			Camera val2 = null;
			if (Object.op_Implicit((Object)(object)componentInParent))
			{
				val2 = componentInParent.worldCamera;
			}
			if (!Object.op_Implicit((Object)(object)val2))
			{
				val2 = (Object.op_Implicit((Object)(object)Utils.localCameraRig) ? Utils.localCameraRig.uiCam : null);
			}
			Plane[] array = null;
			if (Object.op_Implicit((Object)(object)val2))
			{
				try
				{
					array = GeometryUtility.CalculateFrustumPlanes(val2);
				}
				catch (Exception)
				{
					array = null;
				}
			}
			List<Entry> list = new List<Entry>();
			float num = float.MinValue;
			int num2 = 0;
			StringBuilder stringBuilder = new StringBuilder();
			Selectable[] componentsInChildren = ((Component)val).GetComponentsInChildren<Selectable>(false);
			foreach (Selectable val3 in componentsInChildren)
			{
				if (!Object.op_Implicit((Object)(object)val3) || !((Component)val3).gameObject.activeInHierarchy || !val3.IsInteractable() || IsExcluded(val3, val))
				{
					continue;
				}
				Vector3 position = ((Component)val3).transform.position;
				Vector3 val4 = val.InverseTransformPoint(position);
				if (stringBuilder.Length < 80000)
				{
					string text = ((Object)val3).name;
					Transform parent = ((Component)val3).transform.parent;
					int num3 = 0;
					while ((Object)(object)parent != (Object)null && (Object)(object)parent != (Object)(object)val && num3 < 5)
					{
						text = ((Object)parent).name + "/" + text;
						parent = parent.parent;
						num3++;
					}
					string text2 = "n/a";
					if (Object.op_Implicit((Object)(object)val2))
					{
						Vector3 val5 = val2.WorldToScreenPoint(position);
						text2 = $"({val5.x:F0},{val5.y:F0},z{val5.z:F2})";
					}
					string text3 = ((array == null) ? "n/a" : (InsideFrustum(array, position) ? "Y" : "N"));
					string text4 = (Object.op_Implicit((Object)(object)((Component)val3).GetComponentInParent<SurvivorIconController>()) ? "GRID" : "    ");
					stringBuilder.AppendLine($"    [{text4}] '{text}' world=({position.x:F2},{position.y:F2},{position.z:F2}) local=({val4.x:F0},{val4.y:F0}) screen={text2} frustum={text3}");
				}
				if (Object.op_Implicit((Object)(object)((Component)val3).GetComponentInParent<SurvivorIconController>()) && val4.x > num)
				{
					num = val4.x;
				}
				if (array != null && !InsideFrustum(array, position))
				{
					num2++;
					continue;
				}
				list.Add(new Entry
				{
					selectable = val3,
					pos = new Vector2(val4.x, val4.y)
				});
			}
			float num4 = ((num > float.MinValue) ? (num + 100f) : 0f);
			for (int j = 0; j < list.Count; j++)
			{
				Entry value = list[j];
				value.rightSide = value.pos.x > num4;
				list[j] = value;
			}
			int num5 = 0;
			for (int k = 0; k < list.Count; k++)
			{
				if (list[k].rightSide)
				{
					num5++;
				}
				Navigation navigation = list[k].selectable.navigation;
				((Navigation)(ref navigation)).mode = (Mode)4;
				((Navigation)(ref navigation)).selectOnUp = FindNeighbor(list, k, Vector2.up);
				((Navigation)(ref navigation)).selectOnDown = FindNeighbor(list, k, Vector2.down);
				((Navigation)(ref navigation)).selectOnLeft = FindNeighbor(list, k, Vector2.left);
				((Navigation)(ref navigation)).selectOnRight = FindNeighbor(list, k, Vector2.right);
				list[k].selectable.navigation = navigation;
			}
			bool flag = lastFixedCount < 0;
			if (!dumpedLayout || (!dumpedBigLayout && num5 >= 15))
			{
				if (num5 >= 15)
				{
					dumpedBigLayout = true;
				}
				else
				{
					dumpedLayout = true;
				}
				string text5 = (Object.op_Implicit((Object)(object)val2) ? ((Object)val2).name : "NONE");
				string text6 = (Object.op_Implicit((Object)(object)val2) ? $"enabled={((Behaviour)val2).isActiveAndEnabled} pos=({((Component)val2).transform.position.x:F2},{((Component)val2).transform.position.y:F2},{((Component)val2).transform.position.z:F2}) rot=({((Component)val2).transform.eulerAngles.x:F0},{((Component)val2).transform.eulerAngles.y:F0},{((Component)val2).transform.eulerAngles.z:F0}) fov={val2.fieldOfView:F0} near={val2.nearClipPlane:F2} far={val2.farClipPlane:F0}" : "");
				string text7 = (Object.op_Implicit((Object)(object)componentInParent) ? string.Format("name='{0}' mode={1} worldCam={2} pixelRect={3}", ((Object)componentInParent).name, componentInParent.renderMode, Object.op_Implicit((Object)(object)componentInParent.worldCamera) ? ((Object)componentInParent.worldCamera).name : "none", componentInParent.pixelRect) : "NO CANVAS");
				VRMod.StaticLogger.LogInfo((object)("[VR input] Lobby layout: canvas=" + text7 + "; uiCam='" + text5 + "' " + text6 + "; rootCanvas='" + (Object.op_Implicit((Object)(object)componentInParent) ? ((Object)componentInParent.rootCanvas).name : "none") + "'"));
				VRMod.StaticLogger.LogInfo((object)$"[VR input] Lobby controls ({stringBuilder.Length} chars):\n{stringBuilder}");
				VRMod.StaticLogger.LogInfo((object)$"[VR input] Lobby split anchor: gridMaxX={num:F0} -> boundary={((num > float.MinValue) ? (num + 100f) : 0f):F0}; skippedOffCanvas={num2}; firstSweep={flag}");
			}
			if (list.Count > 0 && list.Count != lastFixedCount)
			{
				lastFixedCount = list.Count;
				VRMod.StaticLogger.LogInfo((object)$"[VR input] Lobby: side-confined navigation on {list.Count} control(s) ({list.Count - num5} left / {num5} right, boundary x={num4:F0}, skipped {num2} off-canvas).");
			}
		}
	}
	internal static class RuntimeHands
	{
		private struct BoneSnapshot
		{
			public Transform bone;

			public Vector3 localPosition;

			public Quaternion localRotation;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_OnEnter <>9__6_0;

			public static Func<SkinnedMeshRenderer, bool> <>9__23_0;

			public static Func<bool, bool> <>9__23_4;

			public static Func<Transform, bool> <>9__23_1;

			public static Func<Transform, string> <>9__23_2;

			internal void <Init>b__6_0(orig_OnEnter orig, EntityState self)
			{
				orig.Invoke(self);
				if (!ModConfig.RuntimeHandsDebug.Value)
				{
					return;
				}
				try
				{
					if (Object.op_Implicit((Object)(object)MotionControls.currentBody) && Object.op_Implicit((Object)(object)self.outer) && (Object)(object)self.outer.commonComponents.characterBody == (Object)(object)MotionControls.currentBody)
					{
						VRMod.StaticLogger.LogInfo((object)("[VR debug] state enter: " + ((object)self).GetType().FullName + " (machine: " + self.outer.customName + ")"));
					}
				}
				catch
				{
				}
			}

			internal bool <BakeHandMesh>b__23_0(SkinnedMeshRenderer r)
			{
				return Object.op_Implicit((Object)(object)r.sharedMesh);
			}

			internal bool <BakeHandMesh>b__23_4(bool x)
			{
				return x;
			}

			internal bool <BakeHandMesh>b__23_1(Transform b)
			{
				return Object.op_Implicit((Object)(object)b);
			}

			internal string <BakeHandMesh>b__23_2(Transform b)
			{
				return ((Object)b).name;
			}
		}

		private static bool stateHookApplied;

		private static readonly Dictionary<string, Vector3[]> bodyDefaults = new Dictionary<string, Vector3[]>
		{
			{
				"SeekerBody",
				(Vector3[])(object)new Vector3[3]
				{
					new Vector3(120f, 195f, 150f),
					new Vector3(45f, 10f, 120f),
					new Vector3(60f, -15f, 0f)
				}
			},
			{
				"ChefBody",
				(Vector3[])(object)new Vector3[3]
				{
					new Vector3(280f, 350f, 15f),
					new Vector3(120f, 110f, 160f),
					new Vector3(80f, -15f, 0f)
				}
			},
			{
				"FalseSonBody",
				(Vector3[])(object)new Vector3[3]
				{
					new Vector3(110f, 200f, 140f),
					new Vector3(60f, -25f, 90f),
					new Vector3(60f, -15f, 0f)
				}
			},
			{
				"DroneTechBody",
				(Vector3[])(object)new Vector3[3]
				{
					new Vector3(220f, 10f, 210f),
					new Vector3(60f, -10f, 100f),
					new Vector3(60f, -15f, 0f)
				}
			},
			{
				"DrifterBody",
				(Vector3[])(object)new Vector3[3]
				{
					new Vector3(-100f, 20f, 0f),
					new Vector3(60f, -40f, -30f),
					new Vector3(60f, -15f, 0f)
				}
			}
		};

		internal static readonly string[] KnownRuntimeHandBodies = new string[5] { "SeekerBody", "ChefBody", "FalseSonBody", "DroneTechBody", "DrifterBody" };

		private static readonly Dictionary<string, ConfigEntry<float>[]> weaponEntries = new Dictionary<string, ConfigEntry<float>[]>();

		private static readonly Dictionary<string, float[]> weaponDefaults = new Dictionary<string, float[]> { 
		{
			"DroneTechBody",
			new float[6] { -0.07f, -0.03f, 0f, 15f, -90f, -10f }
		} };

		private static int skinnedCharacterParts;

		private static bool skinPending;

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

		private static Vector3[] DefaultsFor(string bodyName)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			if (bodyDefaults.TryGetValue(bodyName, out var value))
			{
				return value;
			}
			return (Vector3[])(object)new Vector3[3]
			{
				new Vector3(45f, 10f, 120f),
				new Vector3(45f, 10f, 120f),
				new Vector3(60f, -15f, 0f)
			};
		}

		internal static void BindHandEntries(string bodyName, bool leftHand, out ConfigEntry<float> rotX, out ConfigEntry<float> rotY, out ConfigEntry<float> rotZ, out ConfigEntry<float> posX, out ConfigEntry<float> posY, out ConfigEntry<float> posZ, out ConfigEntry<float> scale, out ConfigEntry<float> aimRotX, out ConfigEntry<float> aimRotY, out ConfigEntry<float> aimRotZ)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] array = DefaultsFor(bodyName);
			Vector3 val = (leftHand ? array[0] : array[1]);
			Vector3 val2 = array[2];
			string text = (leftHand ? "Left" : "Right");
			string text2 = (leftHand ? "LEFT" : "RIGHT");
			string text3 = " Applies to the " + text2 + " hand only - the two hands are tuned independently and neither is mirrored from the other.";
			rotX = ModConfig.BindRuntimeHand(bodyName, text + "RotX", val.x, text2 + " HAND MESH rotation offset (degrees) around X." + text3 + " Does not affect the aim/laser.");
			rotY = ModConfig.BindRuntimeHand(bodyName, text + "RotY", val.y, text2 + " HAND MESH rotation offset (degrees) around Y." + text3 + " Does not affect the aim/laser.");
			rotZ = ModConfig.BindRuntimeHand(bodyName, text + "RotZ", val.z, text2 + " HAND MESH rotation offset (degrees) around Z." + text3 + " Does not affect the aim/laser.");
			posX = ModConfig.BindRuntimeHand(bodyName, text + "PosX", 0f, text2 + " HAND MESH position offset (meters) on X." + text3);
			posY = ModConfig.BindRuntimeHand(bodyName, text + "PosY", 0f, text2 + " HAND MESH position offset (meters) on Y." + text3);
			posZ = ModConfig.BindRuntimeHand(bodyName, text + "PosZ", 0f, text2 + " HAND MESH position offset (meters) on Z." + text3);
			scale = ModConfig.BindRuntimeHand(bodyName, "Scale", 1f, "Scale multiplier for this character's runtime hand meshes (both hands).");
			aimRotX = ModConfig.BindRuntimeHand(bodyName, "AimRotX", val2.x, "AIM/LASER rotation offset (degrees) around X. Shared by BOTH hands; does not affect the hand meshes.");
			aimRotY = ModConfig.BindRuntimeHand(bodyName, "AimRotY", val2.y, "AIM/LASER rotation offset (degrees) around Y. Shared by BOTH hands; does not affect the hand meshes.");
			aimRotZ = ModConfig.BindRuntimeHand(bodyName, "AimRotZ", val2.z, "AIM/LASER rotation offset (degrees) around Z. Shared by BOTH hands; does not affect the hand meshes.");
		}

		internal static void PreRegisterKnownBodies()
		{
			string[] knownRuntimeHandBodies = KnownRuntimeHandBodies;
			foreach (string bodyName in knownRuntimeHandBodies)
			{
				BindHandEntries(bodyName, leftHand: true, out var rotX, out var rotY, out var rotZ, out var posX, out var posY, out var posZ, out var scale, out var aimRotX, out var aimRotY, out var aimRotZ);
				BindHandEntries(bodyName, leftHand: false, out rotX, out rotY, out rotZ, out posX, out posY, out posZ, out scale, out aimRotX, out aimRotY, out aimRotZ);
			}
			BindWeaponEntries("DroneTechBody");
		}

		internal static void Init()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			if (stateHookApplied)
			{
				return;
			}
			stateHookApplied = true;
			object obj = <>c.<>9__6_0;
			if (obj == null)
			{
				hook_OnEnter val = delegate(orig_OnEnter orig, EntityState self)
				{
					orig.Invoke(self);
					if (!ModConfig.RuntimeHandsDebug.Value)
					{
						return;
					}
					try
					{
						if (Object.op_Implicit((Object)(object)MotionControls.currentBody) && Object.op_Implicit((Object)(object)self.outer) && (Object)(object)self.outer.commonComponents.characterBody == (Object)(object)MotionControls.currentBody)
						{
							VRMod.StaticLogger.LogInfo((object)("[VR debug] state enter: " + ((object)self).GetType().FullName + " (machine: " + self.outer.customName + ")"));
						}
					}
					catch
					{
					}
				};
				<>c.<>9__6_0 = val;
				obj = (object)val;
			}
			EntityState.OnEnter += (hook_OnEnter)obj;
		}

		internal static Hand TryBuildHand(HandController controller, string bodyName)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Invalid comparison between Unknown and I4
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Expected O, but got Unknown
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Expected O, but got Unknown
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Expected O, but got Unknown
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				CharacterBody currentBody = MotionControls.currentBody;
				if (!Object.op_Implicit((Object)(object)currentBody) || !Object.op_Implicit((Object)(object)currentBody.modelLocator) || !Object.op_Implicit((Object)(object)currentBody.modelLocator.modelTransform))
				{
					VRMod.StaticLogger.LogWarning((object)"[VR hands] Runtime hand: no model transform available.");
					return null;
				}
				Transform modelTransform = currentBody.modelLocator.modelTransform;
				bool flag = (int)controller.xrNode == 4;
				bool flag2 = !flag;
				bool flag3 = flag;
				HashSet<Transform> skeletonBones = CollectSkeletonBones(modelTransform);
				Transform val = FindHandBone(modelTransform, flag2, skeletonBones);
				if (!Object.op_Implicit((Object)(object)val))
				{
					val = FindHandBone(modelTransform, !flag2, skeletonBones);
					if (Object.op_Implicit((Object)(object)val))
					{
						flag3 = !flag3;
						VRMod.StaticLogger.LogWarning((object)("[VR hands] No " + (flag2 ? "right" : "left") + "-side hand bone on '" + bodyName + "'; mirroring the other arm for this hand."));
					}
				}
				if (!Object.op_Implicit((Object)(object)val))
				{
					VRMod.StaticLogger.LogWarning((object)("[VR hands] Runtime hand: no " + (flag2 ? "right" : "left") + "-hand bone found on '" + bodyName + "'. Keeping default pointer."));
					if (ModConfig.RuntimeHandsDebug.Value)
					{
						DumpBones(modelTransform);
					}
					return null;
				}
				HashSet<Transform> hashSet = new HashSet<Transform>(((Component)val).GetComponentsInChildren<Transform>(true));
				if (ModConfig.RuntimeHandsForearm.Value && Object.op_Implicit((Object)(object)val.parent))
				{
					string text = ((Object)val.parent).name.ToLowerInvariant();
					if (text.Contains("arm") || text.Contains("elbow") || text.Contains("wrist"))
					{
						hashSet.Add(val.parent);
					}
				}
				List<RendererInfo> list = new List<RendererInfo>();
				int characterParts;
				GameObject val2 = BakeHandMesh(modelTransform, val, hashSet, bodyName, list, out characterParts);
				if (!Object.op_Implicit((Object)(object)val2))
				{
					VRMod.StaticLogger.LogWarning((object)("[VR hands] Runtime hand: no triangles skinned to '" + ((Object)val).name + "' on '" + bodyName + "'. Keeping default pointer."));
					return null;
				}
				if (characterParts == 0 || (skinPending && skinnedCharacterParts == 0))
				{
					Object.Destroy((Object)(object)val2);
					VRMod.StaticLogger.LogInfo((object)("[VR hands] The character's own meshes are still null for '" + bodyName + "' (only item displays / loose props are loaded so far) - waiting for the skin before baking the hand."));
					return null;
				}
				WireStockDrivenParts(val2, currentBody);
				Quaternion autoAlign = Quaternion.FromToRotation(EstimateFingerDirectionAtBind(modelTransform, val), Vector3.forward);
				GameObject val3 = new GameObject("RuntimeHand_" + bodyName);
				val3.SetActive(false);
				GameObject val4 = new GameObject("AlignedRoot");
				val4.transform.SetParent(val3.transform, false);
				val2.transform.SetParent(val4.transform, false);
				GameObject val5 = new GameObject("AimRoot");
				val5.transform.SetParent(val3.transform, false);
				GameObject val6 = new GameObject("RuntimeMuzzle");
				val6.transform.SetParent(val5.transform, false);
				val6.transform.localPosition = new Vector3(0f, 0f, 0.05f);
				Muzzle muzzle = val6.AddComponent<Muzzle>();
				muzzle.entriesToReplaceIfDominant = new string[0];
				muzzle.entriesToReplaceIfNonDominant = new string[0];
				RuntimeHandAligner runtimeHandAligner = val4.AddComponent<RuntimeHandAligner>();
				runtimeHandAligner.autoAlign = autoAlign;
				runtimeHandAligner.bodyName = bodyName;
				runtimeHandAligner.aimRoot = val5.transform;
				runtimeHandAligner.isLeftHand = flag;
				runtimeHandAligner.mirrorMesh = flag3;
				runtimeHandAligner.builtModelId = ((Object)modelTransform).GetInstanceID();
				runtimeHandAligner.sourceHandBone = val;
				runtimeHandAligner.itemDisplaysAtBuild = CountItemDisplays(val);
				runtimeHandAligner.inventorySumAtBuild = InventorySum(currentBody);
				runtimeHandAligner.BindConfig();
				if (ModConfig.RuntimeHandsDebug.Value)
				{
					try
					{
						AddAxisLines(val4.transform, controller);
					}
					catch (Exception ex)
					{
						VRMod.StaticLogger.LogWarning((object)("[VR debug] Axis lines failed (hand mesh unaffected): " + ex.Message));
					}
				}
				Hand hand = val3.AddComponent<Hand>();
				hand.handType = HandType.Both;
				hand.bodyName = bodyName;
				hand.useRay = ModConfig.RuntimeHandsRay.Value;
				hand.muzzles = new Muzzle[1] { muzzle };
				hand.rendererInfos = list.ToArray();
				hand.copyMaterialsFromCharacterModelIfNoSkin = true;
				val3.transform.SetParent(((Component)controller).transform, false);
				VRMod.StaticLogger.LogInfo((object)string.Format("[VR hands] Runtime hand built for '{0}' [{1} controller] from bone '{2}' ({3} bones, {4} renderer info(s) wired to the game's material pipeline){5}. Tune offsets in config section 'RuntimeHands (experimental)'.", bodyName, flag ? "LEFT" : "RIGHT", ((Object)val).name, hashSet.Count, list.Count, flag3 ? ", un-mirrored" : ""));
				return hand;
			}
			catch (Exception arg)
			{
				VRMod.StaticLogger.LogError((object)$"[VR hands] Runtime hand build failed for '{bodyName}': {arg}");
				return null;
			}
		}

		private static HashSet<Transform> CollectSkeletonBones(Transform model)
		{
			HashSet<Transform> hashSet = new HashSet<Transform>();
			SkinnedMeshRenderer[] componentsInChildren = ((Component)model).GetComponentsInChildren<SkinnedMeshRenderer>(true);
			foreach (SkinnedMeshRenderer val in componentsInChildren)
			{
				if (Object.op_Implicit((Object)(object)((Component)val).GetComponentInParent<ItemDisplay>()) || val.bones == null)
				{
					continue;
				}
				Transform[] bones = val.bones;
				foreach (Transform val2 in bones)
				{
					if (Object.op_Implicit((Object)(object)val2))
					{
						hashSet.Add(val2);
					}
				}
			}
			return hashSet;
		}

		private static Transform FindHandBone(Transform model, bool right, HashSet<Transform> skeletonBones)
		{
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			Transform[] array = ((Component)model).GetComponentsInChildren<Transform>(true);
			if (skeletonBones != null && skeletonBones.Count > 0)
			{
				array = array.Where((Transform t) => skeletonBones.Contains(t)).ToArray();
			}
			string[] source = ((!right) ? new string[9] { "handl", "hand.l", "hand_l", "lefthand", "left_hand", "left hand", "l_hand", "l hand", "hand left" } : new string[9] { "handr", "hand.r", "hand_r", "righthand", "right_hand", "right hand", "r_hand", "r hand", "hand right" });
			Transform[] array2 = array;
			foreach (Transform val in array2)
			{
				string value = ((Object)val).name.ToLowerInvariant().Trim();
				if (source.Contains(value))
				{
					return val;
				}
			}
			Regex regex = new Regex(right ? "((\\.|_|\\s)?r$|(^|[._\\s])r[._\\s])" : "((\\.|_|\\s)?l$|(^|[._\\s])l[._\\s])");
			array2 = array;
			foreach (Transform val2 in array2)
			{
				string text = ((Object)val2).name.ToLowerInvariant().Trim();
				if (text.Contains("hand") && !text.Contains("handle"))
				{
					if (text.Contains(right ? "right" : "left"))
					{
						return val2;
					}
					if (regex.IsMatch(text))
					{
						return val2;
					}
				}
			}
			array2 = array;
			foreach (Transform val3 in array2)
			{
				string text2 = ((Object)val3).name.ToLowerInvariant().Trim();
				if (text2.Contains("wrist"))
				{
					if (text2.Contains(right ? "right" : "left"))
					{
						return LogPickedBone(val3, "wrist name");
					}
					if (regex.IsMatch(text2))
					{
						return LogPickedBone(val3, "wrist name");
					}
				}
			}
			Transform val4 = null;
			int num2 = 0;
			array2 = array;
			foreach (Transform val5 in array2)
			{
				string text3 = ((Object)val5).name.ToLowerInvariant().Trim();
				if (!text3.Contains(right ? "right" : "left") && !regex.IsMatch(text3))
				{
					continue;
				}
				int num3 = 0;
				foreach (Transform item in val5)
				{
					if (IsFingerName(((Object)item).name))
					{
						num3++;
					}
				}
				if (num3 > num2)
				{
					num2 = num3;
					val4 = val5;
				}
			}
			if (Object.op_Implicit((Object)(object)val4))
			{
				return LogPickedBone(val4, $"{num2} finger child bone(s)");
			}
			return null;
		}

		private static bool IsFingerName(string name)
		{
			string text = name.ToLowerInvariant();
			if (!text.Contains("finger") && !text.Contains("thumb") && !text.Contains("index") && !text.Contains("middle") && !text.Contains("pinky") && !text.Contains("ring"))
			{
				return text.Contains("digit");
			}
			return true;
		}

		private static Transform LogPickedBone(Transform bone, string how)
		{
			VRMod.StaticLogger.LogInfo((object)("[VR hands] Hand bone identified as '" + ((Object)bone).name + "' by " + how + " (this rig does not use a 'hand' bone name)."));
			return bone;
		}

		private static void WireStockDrivenParts(GameObject container, CharacterBody body)
		{
			if (!Object.op_Implicit((Object)(object)container) || !Object.op_Implicit((Object)(object)body))
			{
				return;
			}
			try
			{
				GenericSkill val = null;
				GenericSkill[] components = ((Component)body).GetComponents<GenericSkill>();
				foreach (GenericSkill val2 in components)
				{
					Type type = ((Object.op_Implicit((Object)(object)val2) && Object.op_Implicit((Object)(object)val2.skillDef) && ((SerializableEntityStateType)(ref val2.skillDef.activationState)).stateType != null) ? ((SerializableEntityStateType)(ref val2.skillDef.activationState)).stateType : null);
					if (type != null && type.FullName == "EntityStates.DroneTech.Weapon.ThrowDroneBall")
					{
						val = val2;
						break;
					}
				}
				if (!Object.op_Implicit((Object)(object)val))
				{
					return;
				}
				int num = 0;
				RuntimeHandPartMirror[] componentsInChildren = container.GetComponentsInChildren<RuntimeHandPartMirror>(true);
				foreach (RuntimeHandPartMirror runtimeHandPartMirror in componentsInChildren)
				{
					if (Object.op_Implicit((Object)(object)runtimeHandPartMirror.source))
					{
						bool flag = false;
						Transform val3 = ((Component)runtimeHandPartMirror.source).transform;
						while (Object.op_Implicit((Object)(object)val3) && !flag)
						{
							flag = ((Object)val3).name.ToLowerInvariant().Contains("droneball");
							val3 = val3.parent;
						}
						if (flag)
						{
							runtimeHandPartMirror.stockSkill = val;
							num++;
						}
					}
				}
				if (num > 0)
				{
					VRMod.StaticLogger.LogInfo((object)$"[VR hands] {num} drone-ball part(s) now follow the '{val.skillName}' charge (shown while stock > 0).");
				}
			}
			catch (Exception ex)
			{
				VRMod.StaticLogger.LogWarning((object)("[VR hands] Stock-driven part wiring failed: " + ex.Message));
			}
		}

		private static bool IsWeaponBone(Transform t)
		{
			string text = ((Object)t).name.ToLowerInvariant();
			if (!text.StartsWith("weapon") && !text.Contains("_weapon"))
			{
				return text.Contains("weapon_");
			}
			return true;
		}

		internal static ConfigEntry<float>[] BindWeaponEntries(string bodyName)
		{
			if (weaponEntries.TryGetValue(bodyName, out var value))
			{
				return value;
			}
			if (!weaponDefaults.TryGetValue(bodyName, out var value2))
			{
				value2 = new float[6];
			}
			value = new ConfigEntry<float>[6]
			{
				ModConfig.BindRuntimeHand(bodyName, "WeaponPosX", value2[0], "Held WEAPON position offset (metres) on X, relative to the hand bone. Only used when the rig parents a 'weapon' bone to the hand (Operator's gun)."),
				ModConfig.BindRuntimeHand(bodyName, "WeaponPosY", value2[1], "Held WEAPON position offset (metres) on Y, relative to the hand bone."),
				ModConfig.BindRuntimeHand(bodyName, "WeaponPosZ", value2[2], "Held WEAPON position offset (metres) on Z, relative to the hand bone."),
				ModConfig.BindRuntimeHand(bodyName, "WeaponRotX", value2[3], "Held WEAPON rotation offset (degrees) around X, relative to the hand bone."),
				ModConfig.BindRuntimeHand(bodyName, "WeaponRotY", value2[4], "Held WEAPON rotation offset (degrees) around Y, relative to the hand bone."),
				ModConfig.BindRuntimeHand(bodyName, "WeaponRotZ", value2[5], "Held WEAPON rotation offset (degrees) around Z, relative to the hand bone.")
			};
			weaponEntries[bodyName] = value;
			return value;
		}

		private static List<BoneSnapshot> PoseToBind(SkinnedMeshRenderer smr, Transform[] bones, bool[] inSet)
		{
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			List<BoneSnapshot> list = new List<BoneSnapshot>();
			if (!Object.op_Implicit((Object)(object)smr) || !Object.op_Implicit((Object)(object)smr.sharedMesh))
			{
				return list;
			}
			Matrix4x4[] bindposes = smr.sharedMesh.bindposes;
			if (bindposes == null || bindposes.Length != bones.Length)
			{
				return list;
			}
			Dictionary<Transform, int> dictionary = new Dictionary<Transform, int>();
			for (int i = 0; i < bones.Length; i++)
			{
				if (Object.op_Implicit((Object)(object)bones[i]) && !dictionary.ContainsKey(bones[i]))
				{
					dictionary[bones[i]] = i;
				}
			}
			for (int j = 0; j < bones.Length; j++)
			{
				if (inSet[j] && Object.op_Implicit((Object)(object)bones[j]) && Object.op_Implicit((Object)(object)bones[j].parent) && dictionary.TryGetValue(bones[j].parent, out var value))
				{
					Matrix4x4 val = bindposes[value] * ((Matrix4x4)(ref bindposes[j])).inverse;
					Vector3 localPosition = Vector4.op_Implicit(((Matrix4x4)(ref val)).GetColumn(3));
					Quaternion localRotation = Quaternion.LookRotation(Vector4.op_Implicit(((Matrix4x4)(ref val)).GetColumn(2)), Vector4.op_Implicit(((Matrix4x4)(ref val)).GetColumn(1)));
					list.Add(new BoneSnapshot
					{
						bone = bones[j],
						localPosition = bones[j].localPosition,
						localRotation = bones[j].localRotation
					});
					if (IsWeaponBone(bones[j]) && !IsWeaponBone(bones[j].parent))
					{
						localPosition = Vector3.zero;
					}
					bones[j].localRotation = localRotation;
					bones[j].localPosition = localPosition;
				}
			}
			return list;
		}

		private static void RestorePose(List<BoneSnapshot> snapshot)
		{
			//IL_0025: 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)
			foreach (BoneSnapshot item in snapshot)
			{
				if (Object.op_Implicit((Object)(object)item.bone))
				{
					item.bone.localPosition = item.localPosition;
					item.bone.localRotation = item.localRotation;
				}
			}
		}

		private static List<BoneSnapshot> PoseSubtreeToBind(Transform model, Transform root)
		{
			SkinnedMeshRenderer[] componentsInChildren = ((Component)model).GetComponentsInChildren<SkinnedMeshRenderer>(true);
			foreach (SkinnedMeshRenderer val in componentsInChildren)
			{
				if (!Object.op_Implicit((Object)(object)val.sharedMesh))
				{
					continue;
				}
				Transform[] bones = val.bones;
				bool flag = false;
				bool[] array = new bool[bones.Length];
				for (int j = 0; j < bones.Length; j++)
				{
					if (Object.op_Implicit((Object)(object)bones[j]))
					{
						if ((Object)(object)bones[j] == (Object)(object)root)
						{
							flag = true;
						}
						array[j] = (Object)(object)bones[j] == (Object)(object)root || bones[j].IsChildOf(root);
					}
				}
				if (flag)
				{
					return PoseToBind(val, bones, array);
				}
			}
			return new List<BoneSnapshot>();
		}

		private static Vector3 EstimateFingerDirectionAtBind(Transform model, Transform handBone)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			List<BoneSnapshot> snapshot = PoseSubtreeToBind(model, handBone);
			try
			{
				return EstimateFingerDirection(handBone);
			}
			finally
			{
				RestorePose(snapshot);
			}
		}

		private static Vector3 EstimateFingerDirection(Transform handBone)
		{
			//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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Vector3.zero;
			int num = 0;
			foreach (Transform item in handBone)
			{
				Transform val2 = item;
				if (!Object.op_Implicit((Object)(object)((Component)val2).GetComponent<ItemDisplay>()) && !Object.op_Implicit((Object)(object)((Component)val2).GetComponentInChildren<ItemDisplay>(true)) && !IsWeaponBone(val2))
				{
					Vector3 val3 = handBone.InverseTransformPoint(val2.position);
					if (((Vector3)(ref val3)).sqrMagnitude > 1E-08f)
					{
						val += ((Vector3)(ref val3)).normalized;
						num++;
					}
				}
			}
			Vector3 val4;
			if (num > 0 && ((Vector3)(ref val)).sqrMagnitude > 1E-06f)
			{
				val4 = val / (float)num;
				return ((Vector3)(ref val4)).normalized;
			}
			if (Object.op_Implicit((Object)(object)handBone.parent))
			{
				Vector3 val5 = handBone.InverseTransformPoint(handBone.parent.position);
				if (((Vector3)(ref val5)).sqrMagnitude > 1E-08f)
				{
					val4 = -val5;
					return ((Vector3)(ref val4)).normalized;
				}
			}
			return Vector3.forward;
		}

		private static GameObject BakeHandMesh(Transform model, Transform handBone, HashSet<Transform> boneSet, string bodyName, List<RendererInfo> rendererInfos, out int characterParts)
		{
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_0abf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ac6: Expected O, but got Unknown
			//IL_0aa8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aae: Expected O, but got Unknown
			//IL_0af3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0af8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b0b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b10: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b1c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b21: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b37: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b3c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b45: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b4a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b53: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b68: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b6f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b77: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b8c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b93: Unknown result type (might be due to invalid IL or missing references)
			//IL_0548: Unknown result type (might be due to invalid IL or missing references)
			//IL_054f: Expected O, but got Unknown
			//IL_0b9b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bb0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bb7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bbf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0566: Unknown result type (might be due to invalid IL or missing references)
			//IL_0572: Unknown result type (might be due to invalid IL or missing references)
			//IL_057e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0583: Unknown result type (might be due to invalid IL or missing references)
			//IL_0588: Unknown result type (might be due to invalid IL or missing references)
			//IL_058d: Unknown result type (might be due to invalid IL or missing references)
			//IL_058f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0591: Unknown result type (might be due to invalid IL or missing references)
			//IL_0596: Unknown result type (might be due to invalid IL or missing references)
			//IL_076e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0775: Expected O, but got Unknown
			//IL_0679: Unknown result type (might be due to invalid IL or missing references)
			//IL_0697: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0830: Unknown result type (might be due to invalid IL or missing references)
			//IL_0836: Expected O, but got Unknown
			//IL_08b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b7: Expected O, but got Unknown
			//IL_0862: Unknown result type (might be due to invalid IL or missing references)
			characterParts = 0;
			skinnedCharacterParts = 0;
			skinPending = false;
			CharacterModel component = ((Component)model).GetComponent<CharacterModel>();
			GameObject val = null;
			bool value = ModConfig.RuntimeHandsDebug.Value;
			SkinnedMeshRenderer[] componentsInChildren = ((Component)model).GetComponentsInChildren<SkinnedMeshRenderer>(true);
			if (value)
			{
				if (componentsInChildren.Any((SkinnedMeshRenderer r) => Object.op_Implicit((Object)(object)r.sharedMesh)))
				{
					DumpSkeletonTree(model, bodyName);
				}
				VRMod.StaticLogger.LogInfo((object)$"[VR debug] model '{((Object)model).name}': {componentsInChildren.Length} skinned renderer(s), {((Component)model).GetComponentsInChildren<MeshFilter>(true).Length} mesh filter(s).");
			}
			SkinnedMeshRenderer[] array = componentsInChildren;
			foreach (SkinnedMeshRenderer val2 in array)
			{
				if (!Object.op_Implicit((Object)(object)val2.sharedMesh))
				{
					if (value)
					{
						VRMod.StaticLogger.LogInfo((object)("[VR debug] smr '" + ((Object)val2).name + "': sharedMesh is NULL (skin not applied yet?)"));
					}
					skinPending = true;
					continue;
				}
				Transform[] bones = val2.bones;
				Transform val3 = null;
				for (int num2 = 0; num2 < bones.Length; num2++)
				{
					if (Object.op_Implicit((Object)(object)bones[num2]) && ((Object)bones[num2]).name == ((Object)handBone).name)
					{
						val3 = bones[num2];
						break;
					}
				}
				bool[] array2 = new bool[bones.Length];
				bool flag = false;
				int i;
				for (i = 0; i < bones.Length; i++)
				{
					if (!Object.op_Implicit((Object)(object)bones[i]))
					{
						continue;
					}
					if (Object.op_Implicit((Object)(object)val3))
					{
						array2[i] = ((ModConfig.RuntimeHandsForearm.Value && Object.op_Implicit((Object)(object)val3.parent)) ? bones[i].IsChildOf(val3.parent) : bones[i].IsChildOf(val3));
					}
					else
					{
						array2[i] = boneSet.Contains(bones[i]) || boneSet.Any((Transform b) => Object.op_Implicit((Object)(object)b) && ((Object)b).name == ((Object)bones[i]).name);
					}
					flag |= array2[i];
				}
				if (value)
				{
					int num3 = array2.Count((bool x) => x);
					VRMod.StaticLogger.LogInfo((object)string.Format("[VR debug] smr '{0}': mesh='{1}', bones={2}, handBoneInSkeleton={3}, bonesInSet={4}", ((Object)val2).name, ((Object)val2.sharedMesh).name, bones.Length, Object.op_Implicit((Object)(object)val3) ? ((Object)val3).name : "NO", num3));
				}
				if (!flag)
				{
					continue;
				}
				if (value)
				{
					ReportBindDelta(val2, bones, array2);
				}
				_ = (Object.op_Implicit((Object)(object)val3) ? val3 : handBone).worldToLocalMatrix;
				Mesh sharedMesh = val2.sharedMesh;
				BoneWeight[] boneWeights = sharedMesh.boneWeights;
				if (boneWeights == null || boneWeights.Length == 0)
				{
					if (value)
					{
						VRMod.StaticLogger.LogInfo((object)("[VR debug] smr '" + ((Object)val2).name + "': mesh has NO bone weights, skipped."));
					}
					continue;
				}
				bool[] array3 = new bool[bones.Length];
				for (int num4 = 0; num4 < bones.Length; num4++)
				{
					array3[num4] = array2[num4] && Object.op_Implicit((Object)(object)bones[num4]) && IsWeaponBone(bones[num4]);
				}
				float[] array4 = new float[boneWeights.Length];
				float num5 = 0f;
				float num6 = 0f;
				for (int num7 = 0; num7 < boneWeights.Length; num7++)
				{
					BoneWeight val4 = boneWeights[num7];
					float num8 = 0f;
					float num9 = 0f;
					if (((BoneWeight)(ref val4)).boneIndex0 < array2.Length && array2[((BoneWeight)(ref val4)).boneIndex0])
					{
						num8 += ((BoneWeight)(ref val4)).weight0;
						if (array3[((BoneWeight)(ref val4)).boneIndex0])
						{
							num9 += ((BoneWeight)(ref val4)).weight0;
						}
					}
					if (((BoneWeight)(ref val4)).boneIndex1 < array2.Length && array2[((BoneWeight)(ref val4)).boneIndex1])
					{
						num8 += ((BoneWeight)(ref val4)).weight1;
						if (array3[((BoneWeight)(ref val4)).boneIndex1])
						{
							num9 += ((BoneWeight)(ref val4)).weight1;
						}
					}
					if (((BoneWeight)(ref val4)).boneIndex2 < array2.Length && array2[((BoneWeight)(ref val4)).boneIndex2])
					{
						num8 += ((BoneWeight)(ref val4)).weight2;
						if (array3[((BoneWeight)(ref val4)).boneIndex2])
						{
							num9 += ((BoneWeight)(ref val4)).weight2;
						}
					}
					if (((BoneWeight)(ref val4)).boneIndex3 < array2.Length && array2[((BoneWeight)(ref val4)).boneIndex3])
					{
						num8 += ((BoneWeight)(ref val4)).weight3;
						if (array3[((BoneWeight)(ref val4)).boneIndex3])
						{
							num9 += ((BoneWeight)(ref val4)).weight3;
						}
					}
					array4[num7] = num8;
					num6 += num8;
					num5 += num9;
				}
				bool flag2 = num6 > 0f && num5 / num6 > 0.5f;
				List<BoneSnapshot> snapshot = PoseToBind(val2, bones, array2);
				Mesh val5 = new Mesh();
				Matrix4x4 toHand;
				try
				{
					val2.BakeMesh(val5);
					Matrix4x4 worldToLocalMatrix = (Object.op_Implicit((Object)(object)val3) ? val3 : handBone).worldToLocalMatrix;
					Matrix4x4 val6 = Matrix4x4.TRS(((Component)val2).transform.position, ((Component)val2).transform.rotation, Vector3.one);
					toHand = worldToLocalMatrix * val6;
				}
				finally
				{
					RestorePose(snapshot);
				}
				Vector3[] vertices = val5.vertices;
				Vector3[] normals = val5.normals;
				Vector2[] uv = sharedMesh.uv;
				Material[] sharedMaterials = ((Renderer)val2).sharedMaterials;
				List<Material> list = new List<Material>();
				List<int[]> list2 = new List<int[]>();
				Dictionary<int, int> remap = new Dictionary<int, int>();
				List<Vector3> list3 = new List<Vector3>();
				List<Vector3> list4 = new List<Vector3>();
				List<Vector2> list5 = new List<Vector2>();
				for (int num10 = 0; num10 < sharedMesh.subMeshCount; num10++)
				{
					int[] triangles = sharedMesh.GetTriangles(num10);
					List<int> list6 = new List<int>();
					for (int num11 = 0; num11 < triangles.Length; num11 += 3)
					{
						int num12 = triangles[num11];
						int num13 = triangles[num11 + 1];
						int num14 = triangles[num11 + 2];
						if (num12 < array4.Length && num13 < array4.Length && num14 < array4.Length && !((array4[num12] + array4[num13] + array4[num14]) / 3f < 0.3f))
						{
							list6.Add(Remap(num12, remap, list3, list4, list5, vertices, normals, uv, toHand));
							list6.Add(Remap(num13, remap, list3, list4, list5, vertices, normals, uv, toHand));
							list6.Add(Remap(num14, remap, list3, list4, list5, vertices, normals, uv, toHand));
						}
					}
					if (list6.Count > 0)
					{
						list2.Add(list6.ToArray());
						list.Add((num10 < sharedMaterials.Length) ? sharedMaterials[num10] : null);
					}
				}
				Object.Destroy((Object)(object)val5);
				if (value)
				{
					float num15 = ((array4.Length != 0) ? array4.Max() : 0f);
					VRMod.StaticLogger.LogInfo((object)$"[VR debug] smr '{((Object)val2).name}': keptVerts={list3.Count}, maxHandWeight={num15:F2}");
				}
				if (list3.Count == 0)
				{
					continue;
				}
				Mesh val7 = new Mesh();
				((Object)val7).name = "RuntimeHand_" + bodyName + "_" + ((Object)val2).name;
				val7.SetVertices(list3);
				if (list4.Count == list3.Count)
				{
					val7.SetNormals(list4);
				}
				if (list5.Count == list3.Count)
				{
					val7.SetUVs(0, list5);
				}
				val7.subMeshCount = list2.Count;
				for (int num16 = 0; num16 < list2.Count; num16++)
				{
					val7.SetTriangles(list2[num16], num16);
				}
				val7.RecalculateBounds();
				if (list4.Count != list3.Count)
				{
					val7.RecalculateNormals();
				}
				if (!Object.op_Implicit((Object)(object)val))
				{
					val = new GameObject("Mesh");
				}
				Transform val8 = val.transform;
				if (flag2)
				{
					Transform val9 = val.transform.Find("WeaponRoot");
					if (!Object.op_Implicit((Object)(object)val9))
					{
						val9 = new GameObject("WeaponRoot").transform;
						val9.SetParent(val.transform, false);
					}
					val8 = val9;
					if (value)
					{
						VRMod.StaticLogger.LogInfo((object)$"[VR debug] '{((Object)val2).name}' is a held WEAPON part ({num5 / num6:P0} of its hand weight is on weapon bones) - tune it with '{bodyName}_Weapon*'.");
					}
				}
				GameObject val10 = new GameObject(((Object)val2).name);
				val10.transform.SetParent(val8, false);
				val10.AddComponent<MeshFilter>().sharedMesh = val7;
				MeshRenderer val11 = val10.AddComponent<MeshRenderer>();
				((Renderer)val11).sharedMaterials = list.ToArray();
				CopyPropertyBlock((Renderer)(object)val2, (Renderer)(object)val11);
				val10.AddComponent<RuntimeHandPartMirror>().source = (Renderer)(object)val2;
				RegisterRendererInfo(rendererInfos, component, (Renderer)(object)val2, (Renderer)(object)val11, (list.Count > 0) ? list[0] : null);
				if (!TagIfItemDisplay((Renderer)(object)val2, val10))
				{
					characterParts++;
					skinnedCharacterParts++;
				}
				if (ModConfig.RuntimeHandsDebug.Value)
				{
					VRMod.StaticLogger.LogInfo((object)$"[VR debug] runtime hand part from '{((Object)val2).name}': {list3.Count} verts, {list2.Count} submesh(es).");
				}
			}
			HashSet<string> hashSet = new HashSet<string>(from b in boneSet
				where Object.op_Implicit((Object)(object)b)
				select ((Object)b).name);
			MeshFilter[] componentsInChildren2 = ((Component)model).GetComponentsInChildren<MeshFilter>(true);
			foreach (MeshFilter val12 in componentsInChildren2)
			{
				if (!Object.op_Implicit((Object)(object)val12.sharedMesh))
				{
					continue;
				}
				MeshRenderer component2 = ((Component)val12).GetComponent<MeshRenderer>();
				if (!Object.op_Implicit((Object)(object)component2))
				{
					continue;
				}
				Transform parent = ((Component)val12).transform.parent;
				Transform val13 = null;
				bool flag3 = false;
				while (Object.op_Implicit((Object)(object)parent) && (Object)(object)parent != (Object)(object)model.parent)
				{
					if (hashSet.Contains(((Object)parent).name))
					{
						flag3 = true;
					}
					if (((Object)parent).name == ((Object)handBone).name)
					{
						val13 = parent;
						break;
					}
					parent = parent.parent;
				}
				if (flag3)
				{
					Transform val14 = (Object.op_Implicit((Object)(object)val13) ? val13 : handBone);
					if (!Object.op_Implicit((Object)(object)val))
					{
						val = new GameObject("Mesh");
					}
					GameObject val15 = new GameObject(((Object)val12).name + "_rigid");
					val15.transform.SetParent(val.transform, false);
					List<BoneSnapshot> snapshot2 = PoseSubtreeToBind(model, val14);
					try
					{
						val15.transform.localPosition = val14.InverseTransformPoint(((Component)val12).transform.position);
						val15.transform.localRotation = Quaternion.Inverse(val14.rotation) * ((Component)val12).transform.rotation;
					}
					finally
					{
						RestorePose(snapshot2);
					}
					Vector3 lossyScale = val14.lossyScale;
					Vector3 lossyScale2 = ((Component)val12).transform.lossyScale;
					val15.transform.localScale = new Vector3((lossyScale.x != 0f) ? (lossyScale2.x / lossyScale.x) : 1f, (lossyScale.y != 0f) ? (lossyScale2.y / lossyScale.y) : 1f, (lossyScale.z != 0f) ? (lossyScale2.z / lossyScale.z) : 1f);
					val15.AddComponent<MeshFilter>().sharedMesh = val12.sharedMesh;
					MeshRenderer val16 = val15.AddComponent<MeshRenderer>();
					((Renderer)val16).sharedMaterials = ((Renderer)component2).sharedMaterials;
					CopyPropertyBlock((Renderer)(object)component2, (Renderer)(object)val16);
					val15.AddComponent<RuntimeHandPartMirror>().source = (Renderer)(object)component2;
					RegisterRendererInfo(rendererInfos, component, (Renderer)(object)component2, (Renderer)(object)val16, (((Renderer)component2).sharedMaterials != null && ((Renderer)component2).sharedMaterials.Length != 0) ? ((Renderer)component2).sharedMaterials[0] : null);
					if (!TagIfItemDisplay((Renderer)(object)component2, val15))
					{
						characterParts++;
					}
					if (value)
					{
						VRMod.StaticLogger.LogInfo((object)("[VR debug] rigid mesh '" + ((Object)val12).name + "' captured under hand chain (space: " + ((Object)val14).name + ")."));
					}
				}
			}
			return val;
		}

		private static bool TagIfItemDisplay(Renderer source, GameObject part)
		{
			if (!Object.op_Implicit((Object)(object)((Component)source).GetComponentInParent<ItemDisplay>()))
			{
				return false;
			}
			part.AddComponent<RuntimeHandItemPart>();
			if (ModConfig.RuntimeHandsDebug.Value)
			{
				VRMod.StaticLogger.LogInfo((object)("[VR debug] '" + ((Object)source).name + "' is an item display - scaling it on the hand."));
			}
			return true;
		}

		private static void CopyPropertyBlock(Renderer source, Renderer target)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			try
			{
				MaterialPropertyBlock val = new MaterialPropertyBlock();
				source.GetPropertyBlock(val);
				if (!val.isEmpty)
				{
					target.SetPropertyBlock(val);
				}
			}
			catch
			{
			}
		}

		private static void RegisterRendererInfo(List<RendererInfo> infos, CharacterModel charModel, Renderer source, Renderer target, Material fallback)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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)
			Material val = fallback;
			bool ignoreOverlays = false;
			if ((Object)(object)charModel != (Object)null && charModel.baseRendererInfos != null)
			{
				RendererInfo[] baseRendererInfos = charModel.baseRendererInfos;
				foreach (RendererInfo val2 in baseRendererInfos)
				{
					if (!((Object)(object)val2.renderer != (Object)(object)source))
					{
						if (Object.op_Implicit((Object)(object)val2.defaultMaterial))
						{
							val = val2.defaultMaterial;
						}
						ignoreOverlays = val2.ignoreOverlays;
						break;
					}
				}
			}
			if (Object.op_Implicit((Object)(object)val))
			{
				target.sharedMaterial = val;
				infos.Add(new RendererInfo
				{
					renderer = target,
					defaultMaterial = val,
					defaultShadowCastingMode = (ShadowCastingMode)0,
					ignoreOverlays = ignoreOverlays
				});
			}
		}

		private static int Remap(int src, Dictionary<int, int> remap, List<Vector3> verts, List<Vector3> normals, List<Vector2> uvs, Vector3[] bakedVerts, Vector3[] bakedNormals, Vector2[] uv, Matrix4x4 toHand)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if (remap.TryGetValue(src, out var value))
			{
				return value;
			}
			value = (remap[src] = verts.Count);
			verts.Add(((Matrix4x4)(ref toHand)).MultiplyPoint3x4(bakedVerts[src]));
			if (bakedNormals != null && src < bakedNormals.Length)
			{
				Vector3 val = ((Matrix4x4)(ref toHand)).MultiplyVector(bakedNormals[src]);
				normals.Add(((Vector3)(ref val)).normalized);
			}
			if (uv != null && src < uv.Length)
			{
				uvs.Add(uv[src]);
			}
			return value;
		}

		private static void AddAxisLines(Transform parent, HandController controller)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			Material val = null;
			LineRenderer val2 = (Object.op_Implicit((Object)(object)controller) ? ((Component)controller).GetComponentInChildren<LineRenderer>(true) : null);
			if (Object.op_Implicit((Object)(object)val2) && Object.op_Implicit((Object)(object)((Renderer)val2).sharedMaterial))
			{
				val = ((Renderer)val2).sharedMaterial;
			}
			if (!Object.op_Implicit((Object)(object)val))
			{
				Shader val3 = TryFindShader("Sprites/Default", "UI/Default", "Hidden/Internal-Colored", "Standard");
				if (Object.op_Implicit((Object)(object)val3))
				{
					val = new Material(val3);
				}
			}
			if (!Object.op_Implicit((Object)(object)val))
			{
				VRMod.StaticLogger.LogWarning((object)"[VR debug] No usable material for axis lines - skipping them (hand mesh unaffected).");
				return;
			}
			AddAxisLine(parent, Vector3.right, Color.red, val);
			AddAxisLine(parent, Vector3.up, Color.green, val);
			AddAxisLine(parent, Vector3.forward, Color.blue, val);
		}

		private static Shader TryFindShader(params string[] names)
		{
			foreach (string text in names)
			{
				try
				{
					Shader val = Shader.Find(text);
					if (Object.op_Implicit((Object)(object)val))
					{
						return val;
					}
				}
				catch
				{
				}
			}
			return null;
		}

		private static void AddAxisLine(Transform parent, Vector3 dir, Color color, Material baseMat)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject($"DebugAxis_{dir}");
			val.transform.SetParent(parent, false);
			LineRenderer obj = val.AddComponent<LineRenderer>();
			obj.useWorldSpace = false;
			obj.positionCount = 2;
			obj.SetPosition(0, Vector3.zero);
			obj.SetPosition(1, dir * 0.08f);
			obj.startWidth = 0.004f;
			obj.endWidth = 0.001f;
			Material val2 = new Material(baseMat);
			val2.color = color;
			((Renderer)obj).material = val2;
			obj.startColor = color;
			obj.endColor = color;
		}

		internal static void ScheduleRetry(HandController controller, string bodyName)
		{
			if (Object.op_Implicit((Object)(object)controller) && !Object.op_Implicit((Object)(object)((Component)controller).GetComponent<RuntimeHandRetry>()))
			{
				RuntimeHandRetry runtimeHandRetry = ((Component)controller).gameObject.AddComponent<RuntimeHandRetry>();
				runtimeHandRetry.controller = controller;
				runtimeHandRetry.bodyName = bodyName;
			}
		}

		internal static int InventorySum(CharacterBody body)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected I4, but got Unknown
			if (!Object.op_Implicit((Object)(object)body) || !Object.op_Implicit((Object)(object)body.inventory))
			{
				return 0;
			}
			int num = 0;
			try
			{
				List<ItemIndex> itemAcquisitionOrder = body.inventory.itemAcquisitionOrder;
				if (itemAcquisitionOrder != null)
				{
					for (int i = 0; i < itemAcquisitionOrder.Count; i++)
					{
						num += itemAcquisitionOrder[i] + body.inventory.GetItemCount(itemAcquisitionOrder[i]) * 31;
					}
				}
			}
			catch
			{
			}
			return num;
		}

		internal static int CountItemDisplays(Transform bone)
		{
			if (!Object.op_Implicit((Object)(object)bone))
			{
				return 0;
			}
			return ((Component)bone).GetComponentsInChildren<ItemDisplay>(true).Length;
		}

		private static void DumpSkeletonTree(Transform model, string bodyName)
		{
			if (!dumpedModels.Add(bodyName))
			{
				return;
			}
			try
			{
				Transform val = null;
				SkinnedMeshRenderer[] componentsInChildren = ((Component)model).GetComponentsInChildren<SkinnedMeshRenderer>(true);
				foreach (SkinnedMeshRenderer val2 in componentsInChildren)
				{
					if (Object.op_Implicit((Object)(object)val2.rootBone))
					{
						val = val2.rootBone;
						while (Object.op_Implicit((Object)(object)val.parent) && (Object)(object)val.parent != (Object)(object)model)
						{
							val = val.parent;
						}
						break;
					}
				}
				if (!Object.op_Implicit((Object)(object)val))
				{
					val = model;
				}
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("[VR debug] Skeleton tree for '" + bodyName + "' (root '" + ((Object)val).name + "'):");
				AppendTree(stringBuilder, val, 0, 0);
				VRMod.StaticLogger.LogInfo((object)stringBuilder.ToString());
			}
			catch (Exception ex)
			{
				VRMod.StaticLogger.LogWarning((object)("[VR debug] Skeleton dump failed: " + ex.Message));
			}
		}

		private static void AppendTree(StringBuilder sb, Transform t, int depth, int count)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			if (depth > 12 || sb.Length > 60000)
			{
				return;
			}
			sb.Append(' ', depth * 2).Append(((Object)t).name);
			if (Object.op_Implicit((Object)(object)((Component)t).GetComponent<ItemDisplay>()))
			{
				sb.Append(" [item display]");
			}
			if (Object.op_Implicit((Object)(object)((Component)t).GetComponent<Renderer>()))
			{
				sb.Append(" [renderer]");
			}
			sb.Append($" lp={t.localPosition} ls={t.localScale}");
			sb.AppendLine();
			foreach (Transform item in t)
			{
				Transform t2 = item;
				AppendTree(sb, t2, depth + 1, count + 1);
			}
		}

		private static void ReportBindDelta(SkinnedMeshRenderer smr, Transform[] bones, bool[] inSet)
		{
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: 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_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Matrix4x4[] bindposes = smr.sharedMesh.bindposes;
				if (bindposes == null || bindposes.Length != bones.Length)
				{
					return;
				}
				Dictionary<Transform, int> dictionary = new Dictionary<Transform, int>();
				for (int i = 0; i < bones.Length; i++)
				{
					if (Object.op_Implicit((Object)(object)bones[i]) && !dictionary.ContainsKey(bones[i]))
					{
						dictionary[bones[i]] = i;
					}
				}
				StringBuilder stringBuilder = new StringBuilder("[VR debug] bind-vs-live for '" + ((Object)smr).name + "':");
				int num = 0;
				for (int j = 0; j < bones.Length; j++)
				{
					if (!inSet[j] || !Object.op_Implicit((Object)(object)bones[j]) || !Object.op_Implicit((Object)(object)bones[j].parent))
					{
						continue;
					}
					if (!dictionary.TryGetValue(bones[j].parent, out var value))
					{
						stringBuilder.Append(" " + ((Object)bones[j]).name + "(parent '" + ((Object)bones[j].parent).name + "' not in skeleton)");
						continue;
					}
					Matrix4x4 val = bindposes[value] * ((Matrix4x4)(ref bindposes[j])).inverse;
					Vector3 val2 = Vector4.op_Implicit(((Matrix4x4)(ref val)).GetColumn(3));
					Quaternion val3 = Quaternion.LookRotation(Vector4.op_Implicit(((Matrix4x4)(ref val)).GetColumn(2)), Vector4.op_Implicit(((Matrix4x4)(ref val)).GetColumn(1)));
					float num2 = Vector3.Distance(val2, bones[j].localPosition);
					float num3 = Quaternion.Angle(val3, bones[j].localRotation);
					if (num2 > 0.02f || num3 > 15f)
					{
						stringBuilder.Append($" {((Object)bones[j]).name}[dPos={num2:F3} dRot={num3:F0} bindLP={val2} liveLP={bones[j].localPosition}]");
						num++;
					}
				}
				if (num == 0)
				{
					stringBuilder.Append(" (all bones within 2 cm / 15 deg of bind pose)");
				}
				VRMod.StaticLogger.LogInfo((object)stringBuilder.ToString());
			}
			catch (Exception ex)
			{
				VRMod.StaticLogger.LogWarning((object)("[VR debug] bind delta failed: " + ex.Message));
			}
		}

		private static void DumpBones(Transform model)
		{
			StringBuilder stringBuilder = new StringBuilder("[VR debug] model bones: ");
			Transform[] componentsInChildren = ((Component)model).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				stringBuilder.Append(((Object)val).name).Append(", ");
			}
			VRMod.StaticLogger.LogInfo((object)stringBuilder.ToString());
		}
	}
	internal class RuntimeHandPartMirror : MonoBehaviour
	{
		internal Renderer source;

		internal bool sourceHidden;

		internal GenericSkill stockSkill;

		private Renderer own;

		private float nextCheck;

		private bool seenActive;

		private void Awake()
		{
			own = ((Component)this).GetComponent<Renderer>();
		}

		private void Update()
		{
			if (Time.unscaledTime < nextCheck)
			{
				return;
			}
			nextCheck = Time.unscaledTime + 0.1f;
			if (!Object.op_Implicit((Object)(object)own) || !Object.op_Implicit((Object)(object)source))
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)stockSkill))
			{
				bool flag = stockSkill.stock > 0;
				sourceHidden = !flag;
				if (own.enabled != flag)
				{
					own.enabled = flag;
				}
				return;
			}
			bool activeSelf = ((Component)source).gameObject.activeSelf;
			if (activeSelf)
			{
				seenActive = true;
			}
			bool flag2 = !seenActive || activeSelf;
			sourceHidden = !flag2;
			if (own.enabled != flag2)
			{
				own.enabled = flag2;
			}
		}
	}
	internal class RuntimeHandAligner : MonoBehaviour
	{
		internal Quaternion autoAlign = Quaternion.identity;

		internal string bodyName;

		internal Transform aimRoot;

		internal bool isLeftHand;

		internal bool mirrorMesh;

		internal int builtModelId;

		internal Transform sourceHandBone;

		internal int itemDisplaysAtBuild;

		internal int inventorySumAtBuild;

		private ConfigEntry<float> rotX;

		private ConfigEntry<float> rotY;

		private ConfigEntry<float> rotZ;

		private ConfigEntry<float> posX;

		private ConfigEntry<float> posY;

		private ConfigEntry<float> posZ;

		private ConfigEntry<float> scale;

		private ConfigEntry<float> aimRotX;

		private ConfigEntry<float> aimRotY;

		private ConfigEntry<float> aimRotZ;

		private ConfigEntry<float>[] weapon;

		private Transform weaponRoot;

		private float nextReload;

		private float nextWatchdog;

		private float inventoryRebakeNotBefore = Time.unscaledTime + 2f;

		private float nextRenderReport;

		private bool forearmAtBuild;

		private bool rebuildRequested;

		internal void BindConfig()
		{
			RuntimeHands.BindHandEntries(bodyName, isLeftHand, out rotX, out rotY, out rotZ, out posX, out posY, out posZ, out scale, out aimRotX, out aimRotY, out aimRotZ);
			string text = (isLeftHand ? "Left" : "Right");
			VRMod.StaticLogger.LogInfo((object)$"[VR hands] '{bodyName}' {text.ToUpperInvariant()} hand offsets: Rot({rotX.Value:F0}, {rotY.Value:F0}, {rotZ.Value:F0}) Pos({posX.Value:F2}, {posY.Value:F2}, {posZ.Value:F2}) Scale {scale.Value:F2} | Aim({aimRotX.Value:F0}, {aimRotY.Value:F0}, {aimRotZ.Value:F0}, shared by both hands). Edit '{bodyName}_{text}*' in the config to tune this hand.");
			forearmAtBuild = ModConfig.RuntimeHandsForearm.Value;
			weaponRoot = ((Component)this).transform.Find("Mesh/WeaponRoot");
			if (Object.op_Implicit((Object)(object)weaponRoot))
			{
				weapon = RuntimeHands.BindWeaponEntries(bodyName);
				VRMod.StaticLogger.LogInfo((object)$"[VR hands] '{bodyName}' {text.ToUpperInvariant()} hand carries a weapon part: offsets Pos({weapon[0].Value:F2}, {weapon[1].Value:F2}, {weapon[2].Value:F2}) Rot({weapon[3].Value:F0}, {weapon[4].Value:F0}, {weapon[5].Value:F0}). Edit '{bodyName}_Weapon*' in the config (live with Debug mode).");
			}
		}

		private void EnsureVisible()
		{
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			HandController componentInParent = ((Component)this).GetComponentInParent<HandController>();
			bool flag = Object.op_Implicit((Object)(object)componentInParent) && componentInParent.uiMode;
			MeshRenderer[] componentsInChildren = ((Component)this).GetComponentsInChildren<MeshRenderer>(true);
			int num = 0;
			MeshRenderer[] array = componentsInChildren;
			foreach (MeshRenderer val in array)
			{
				if (!Object.op_Implicit((Object)(object)val))
				{
					continue;
				}
				RuntimeHandPartMirror component = ((Component)val).GetComponent<RuntimeHandPartMirror>();
				if (!Object.op_Implicit((Object)(object)component) || !component.sourceHidden)
				{
					if (!((Renderer)val).enabled)
					{
						((Renderer)val).enabled = true;
						num++;
					}
					if (!((Component)val).gameObject.activeSelf)
					{
						((Component)val).gameObject.SetActive(true);
						num++;
					}
					if (!flag && ((Component)val).gameObject.layer == LayerIndex.noDraw.intVal)
					{
						((Component)val).gameObject.layer = 0;
						num++;
					}
				}
			}
			if (num > 0)
			{
				VRMod.StaticLogger.LogInfo((object)string.Format("[VR hands] Restored visibility on {0} renderer state(s) for the {1} '{2}' hand.", num, isLeftHand ? "left" : "right", bodyName));
			}
			if (ModConfig.RuntimeHandsDebug.Value && Time.unscaledTime >= nextRenderReport)
			{
				nextRenderReport = Time.unscaledTime + 5f;
				if (componentsInChildren.Length == 0)
				{
					VRMod.StaticLogger.LogInfo((object)("[VR debug] " + (isLeftHand ? "LEFT" : "RIGHT") + " '" + bodyName + "' hand has NO renderers."));
					return;
				}
				MeshRenderer val2 = componentsInChildren[0];
				string text = (Object.op_Implicit((Object)(object)((Renderer)val2).sharedMaterial) ? ((Object)((Renderer)val2).sharedMaterial).name : "NULL");
				VRMod.StaticLogger.LogInfo((object)string.Format("[VR debug] {0} '{1}' hand: {2} renderer(s), first enabled={3}, active={4}, layer={5}, uiMode={6}, material='{7}', visible={8}, worldScale={9}.", isLeftHand ? "LEFT" : "RIGHT", bodyName, componentsInChildren.Length, ((Renderer)val2).enabled, ((Component)val2).gameObject.activeInHierarchy, ((Component)val2).gameObject.layer, flag, text, ((Renderer)val2).isVisible, ((Component)this).transform.lossyScale));
			}
		}

		private void Update()
		{
			//IL_0009: 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_0013: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			if (rotX == null)
			{
				return;
			}
			Quaternion val = Quaternion.Inverse(HandController.PoseCorrection);
			((Component)this).transform.localRotation = val * Quaternion.Euler(rotX.Value, rotY.Value, rotZ.Value) * autoAlign;
			((Component)this).transform.localPosition = new Vector3(posX.Value, posY.Value, posZ.Value);
			float num = Mathf.Clamp(scale.Value, 0.05f, 5f);
			((Component)this).transform.localScale = new Vector3(mirrorMesh ? (0f - num) : num, num, num);
			if (Object.op_Implicit((Object)(object)aimRoot))
			{
				aimRoot.localRotation = val * Quaternion.Euler(aimRotX.Value, aimRotY.Value, aimRotZ.Value);
			}
			if (Object.op_Implicit((Object)(object)weaponRoot) && weapon != null)
			{
				weaponRoot.localPosition = new Vector3(weapon[0].Value, weapon[1].Value, weapon[2].Value);
				weaponRoot.localRotation = Quaternion.Euler(weapon[3].Value, weapon[4].Value, weapon[5].Value);
			}
			if (ModConfig.RuntimeHandsDebug.Value && Time.unscaledTime >= nextReload)
			{
				nextReload = Time.unscaledTime + 3f;
				ModConfig.ReloadRuntimeHandConfig();
			}
			if (!rebuildRequested && Time.unscaledTime >= nextWatchdog)
			{
				nextWatchdog = Time.unscaledTime + 1f;
				CharacterBody currentBody = MotionControls.currentBody;
				Transform val2 = ((Object.op_Implicit((Object)(object)currentBody) && Object.op_Implicit((Object)(object)currentBody.modelLocator)) ? currentBody.modelLocator.modelTransform : null);
				bool flag = Object.op_Implicit((Object)(object)val2) && ((Object)val2).GetInstanceID() != builtModelId;
				bool flag2 = ((Component)this).GetComponentsInChildren<MeshRenderer>(true).Length == 0;
				bool flag3 = Object.op_Implicit((Object)(object)currentBody) && RuntimeHands.InventorySum(currentBody) != inventorySumAtBuild && Time.unscaledTime >= inventoryRebakeNotBefore;
				if ((flag || flag2 || flag3) && Object.op_Implicit((Object)(object)currentBody) && ((Object)currentBody).name.StartsWith(bodyName))
				{
					rebuildRequested = true;
					string text = (flag ? "character model was rebuilt" : (flag2 ? "mesh renderers are gone" : "inventory changed"));
					VRMod.StaticLogger.LogInfo((object)("[VR hands] Runtime hand for '" + bodyName + "' needs re-baking (" + text + ")."));
					MotionControls.SetHandPair(currentBody);
					return;
				}
				EnsureVisible();
			}
			if (!rebuildRequested && ModConfig.RuntimeHandsForearm.Value != forearmAtBuild)
			{
				CharacterBody currentBody2 = MotionControls.currentBody;
				if (Object.op_Implicit((Object)(object)currentBody2) && ((Object)currentBody2).name.StartsWith(bodyName))
				{
					rebuildRequested = true;
					VRMod.StaticLogger.LogInfo((object)"[VR hands] 'Include forearm' changed - rebaking runtime hands.");
					MotionControls.SetHandPair(currentBody2);
				}
			}
		}
	}
	internal class RuntimeHandItemPart : MonoBehaviour
	{
		private Vector3 authoredScale;

		private bool captured;

		private void Update()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			if (!captured)
			{
				authoredScale = ((Component)this).transform.localScale;
				captured = true;
			}
			float num = Mathf.Clamp(ModConfig.RuntimeHandsItemScale.Value, 0.05f, 3f);
			Vector3 val = authoredScale * num;
			Vector3 val2 = ((Component)this).transform.localScale - val;
			if (((Vector3)(ref val2)).sqrMagnitude > 1E-10f)
			{
				((Component)this).transform.localScale = val;
			}
		}
	}
	internal class RuntimeHandRetry : MonoBehaviour
	{
		internal HandController controller;

		internal string bodyName;

		private float nextTry;

		private int attempts;

		private const int maxAttempts = 60;

		private void Update()
		{
			if (!Object.op_Implicit((Object)(object)controller) || string.IsNullOrEmpty(bodyName))
			{
				Object.Destroy((Object)(object)this);
				return;
			}
			if (Object.op_Implicit((Object)(object)controller.currentHand) && controller.currentHand.bodyName == bodyName)
			{
				Object.Destroy((Object)(object)this);
				return;
			}
			CharacterBody currentBody = MotionControls.currentBody;
			if (!Object.op_Implicit((Object)(object)currentBody) || !((Object)currentBody).name.StartsWith(bodyName))
			{
				Object.Destroy((Object)(object)this);
			}
			else if (!(Time.unscaledTime < nextTry))
			{
				nextTry = Time.unscaledTime + 0.5f;
				attempts++;
				Hand hand = RuntimeHands.TryBuildHand(controller, bodyName);
				if (Object.op_Implicit((Object)(object)hand))
				{
					Object.Destroy((Object)(object)((Component)hand).gameObject);
					VRMod.StaticLogger.LogInfo((object)$"[VR hands] Model meshes ready after {attempts} attempt(s) - reapplying hand pair for '{bodyName}'.");
					MotionControls.SetHandPair(currentBody);
					Object.Destroy((Object)(object)this);
				}
				else if (attempts >= 60)
				{
					VRMod.StaticLogger.LogWarning((object)$"[VR hands] Runtime hand retry gave up after {60} attempts for '{bodyName}'.");
					Object.Destroy((Object)(object)this);
				}
			}
		}
	}
	internal static class MenuSubmitGuard
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Update <0>__GuardUpdate;
		}

		private const int UISubmitActionId = 14;

		private static int lastSubmitClickFrame = -1000;

		private static string lastSubmitClickName = "";

		internal static void Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			object obj = <>O.<0>__GuardUpdate;
			if (obj == null)
			{
				hook_Update val = GuardUpdate;
				<>O.<0>__GuardUpdate = val;
				obj = (object)val;
			}
			MPButton.Update += (hook_Update)obj;
		}

		private static void GuardUpdate(orig_Update orig, MPButton self)
		{
			if (WouldSubmitClick(self))
			{
				int frameCount = Time.frameCount;
				if (frameCount - lastSubmitClickFrame <= 1)
				{
					VRMod.StaticLogger.LogInfo((object)("[VR input] Ignored a second menu activation from the same press: '" + ((Object)self).name + "' (that press already activated '" + lastSubmitClickName + "')."));
					return;
				}
				lastSubmitClickFrame = frameCount;
				lastSubmitClickName = ((Object)self).name;
			}
			orig.Invoke(self);
		}

		private static bool WouldSubmitClick(MPButton button)
		{
			MPEventSystem eventSystem = button.eventSystem;
			if (!Object.op_Implicit((Object)(object)eventSystem) || eventSystem.player == null)
			{
				return false;
			}
			if (MPButton.isIgnore || button.disableGamepadClick || button.useBaseGamepadClick)
			{
				return false;
			}
			if (!eventSystem.player.GetButtonDown(14))
			{
				return false;
			}
			return (Object)(object)((EventSystem)eventSystem).currentSelectedGameObject == (Object)(object)((Component)button).gameObject;
		}
	}
	internal static class RewiredAddons
	{
		private static bool loggedActions;

		internal static CustomController CreateRewiredController()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Expected O, but got Unknown
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Expected O, but got Unknown
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Expected O, but got Unknown
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Expected O, but got Unknown
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Expected O, but got Unknown
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Expected O, but got Unknown
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Expected O, but got Unknown
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Expected O, but got Unknown
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Expected O, but got Unknown
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Expected O, but got Unknown
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Expected O, but got Unknown
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Expected O, but got Unknown
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Expected O, but got Unknown
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Expected O, but got Unknown
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Expected O, but got Unknown
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Expected O, but got Unknown
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Expected O, but got Unknown
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Expected O, but got Unknown
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Expected O, but got Unknown
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Expected O, but got Unknown
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Expected O, but got Unknown
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Expected O, but got Unknown
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Expected O, but got Unknown
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0407: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			//IL_042a: Unknown result type (might be due to invalid IL or missing references)
			//IL_042f: Unknown result type (might be due to invalid IL or missing references)
			//IL_044d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0452: Unknown result type (might be due to invalid IL or missing references)
			//IL_0470: Unknown result type (might be due to invalid IL or missing references)
			//IL_0475: Unknown result type (might be due to invalid IL or missing references)
			//IL_0490: Unknown result type (might be due to invalid IL or missing references)
			//IL_0496: Expected O, but got Unknown
			//IL_04a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Expected O, but got Unknown
			//IL_04b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b6: Expected O, but got Unknown
			//IL_04c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c6: Expected O, but got Unknown
			//IL_04d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d6: Expected O, but got Unknown
			//IL_04e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e6: Expected O, but got Unknown
			//IL_04ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f3: Expected O, but got Unknown
			//IL_0523: Unknown result type (might be due to invalid IL or missing references)
			//IL_0528: Unknown result type (might be due to invalid IL or missing references)
			//IL_0537: Unknown result type (might be due to invalid IL or missing references)
			//IL_063d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0643: Invalid comparison between Unknown and I4
			//IL_0635: Unknown result type (might be due to invalid IL or missing references)
			HardwareControllerMap_Game val = new HardwareControllerMap_Game("VRControllers", (ControllerElementIdentifier[])(object)new ControllerElementIdentifier[33]
			{
				new ControllerElementIdentifier(0, "MoveX", "MoveXPos", "MoveXNeg", (ControllerElementType)0, true),
				new ControllerElementIdentifier(1, "MoveY", "MoveYPos", "MoveYNeg", (ControllerElementType)0, true),
				new ControllerElementIdentifier(2, "LookX", "LookXPos", "LookXNeg", (ControllerElementType)0, true),
				new ControllerElementIdentifier(3, "LookY", "LookYPos", "LookYNeg", (ControllerElementType)0, true),
				new ControllerElementIdentifier(4, "NavigateX", "NavigateXPos", "NavigateXNeg", (ControllerElementType)0, true),
				new ControllerElementIdentifier(5, "NavigateY", "NavigateYPos", "NavigateYNeg", (ControllerElementType)0, true),
				new ControllerElementIdentifier(6, "Interact", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(7, "Jump", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(8, "PrimarySkill", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(9, "SecondarySkill", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(10, "UtilitySkill", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(11, "SpecialSkill", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(12, "Equipment", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(13, "Sprint", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(14, "Ping", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(15, "Info", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(16, "HoldInfo", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(17, "Submit", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(18, "Cancel", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(19, "Ready", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(20, "TabLeft", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(21, "TabRight", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(22, "SubmenuLeft", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(23, "SubmenuRight", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(24, "Pause", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(25, "RecenterHMD", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(26, "ExtraSkill1", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(27, "ExtraSkill2", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(28, "ExtraSkill3", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(29, "ExtraSkill4", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(30, "PushToTalk", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(31, "BuySkill", "", "", (ControllerElementType)1, true),
				new ControllerElementIdentifier(32, "Load", "", "", (ControllerElementType)1, true)
			}, new int[0], new int[0], (AxisCalibrationData[])(object)new AxisCalibrationData[6]
			{
				new AxisCalibrationData(true, 0.1f, 0f, -1f, 1f, false, true),
				new AxisCalibrationData(true, 0.1f, 0f, -1f, 1f, false, true),
				new AxisCalibrationData(true, 0.1f, 0f, -1f, 1f, false, true),
				new AxisCalibrationData(true, 0.1f, 0f, -1f, 1f, false, true),
				new AxisCalibrationData(true, 0.1f, 0f, -1f, 1f, false, true),
				new AxisCalibrationData(true, 0.1f, 0f, -1f, 1f, false, true)
			}, (AxisRange[])(object)new AxisRange[6], (HardwareAxisInfo[])(object)new HardwareAxisInfo[6]
			{
				new HardwareAxisInfo((AxisCoordinateMode)0, false, 0f, (SpecialAxisType)0),
				new HardwareAxisInfo((AxisCoordinateMode)0, false, 0f, (SpecialAxisType)0),
				new HardwareAxisInfo((AxisCoordinateMode)0, false, 0f, (SpecialAxisType)0),
				new HardwareAxisInfo((AxisCoordinateMode)0, false, 0f, (SpecialAxisType)0),
				new HardwareAxisInfo((AxisCoordinateMode)0, false, 0f, (SpecialAxisType)0),
				new HardwareAxisInfo((AxisCoordinateMode)0, false, 0f, (SpecialAxisType)0)
			}, (HardwareButtonInfo[])(object)new HardwareButtonInfo[0], (CompoundElement[])null);
			ReInput.UserData.AddCustomController();
			CustomController_Editor val2 = ReInput.UserData.customControllers.Last();
			val2.name = "VRControllers";
			Enumerator<int, ControllerElementIdentifier> enumerator = val.elementIdentifiers.Values.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					ControllerElementIdentifier current = enumerator.Current;
					if ((int)current.elementType == 0)
					{
						val2.AddAxis();
						val2.elementIdentifiers.RemoveAt(val2.elementIdentifiers.Count - 1);
						val2.elementIdentifiers.Add(current);
						Axis obj = val2.axes.Last();
						((Element)obj).name = current.name;
						((Element)obj).elementIdentifierId = current.id;
						obj.deadZone = val.hwAxisCalibrationData[val2.axisCount - 1].deadZone;
						obj.zero = 0f;
						obj.min = val.hwAxisCalibrationData[val2.axisCount - 1].min;
						obj.max = val.hwAxisCalibrationData[val2.axisCount - 1].max;
						obj.invert = val.hwAxisCalibrationData[val2.axisCount - 1].invert;
						obj.axisInfo = val.hwAxisInfo[val2.axisCount - 1];
						obj.range = val.hwAxisRanges[val2.axisCount - 1];
					}
					else if ((int)current.elementType == 1)
					{
						val2.AddButton();
						val2.elementIdentifiers.RemoveAt(val2.elementIdentifiers.Count - 1);
						val2.elementIdentifiers.Add(current);
						Button obj2 = val2.buttons.Last();
						((Element)obj2).name = current.name;
						((Element)obj2).elementIdentifierId = current.id;
					}
				}
			}
			finally
			{
				((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			CustomController obj3 = ReInput.controllers.CreateCustomController(val2.id);
			obj3.fmBTlFnPYkQjybJbRMoAzyIqIRr = false;
			return obj3;
		}

		private static int ResolveActionId(string actionName, int fallbackId)
		{
			try
			{
				int actionId = ReInput.mapping.GetActionId(actionName);
				if (actionId >= 0)
				{
					return actionId;
				}
			}
			catch
			{
			}
			VRMod.StaticLogger.LogWarning((object)$"[VR input] Rewired has no action named '{actionName}'; falling back to id {fallbackId}.");
			return fallbackId;
		}

		private static void LogActions()
		{
			if (loggedActions)
			{
				return;
			}
			loggedActions = true;
			try
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("[VR input] Rewired actions (id = name):");
				foreach (InputAction action in ReInput.mapping.Actions)
				{
					stringBuilder.AppendLine($"    {action.id} = {action.name}");
				}
				VRMod.StaticLogger.LogInfo((object)stringBuilder.ToString());
			}
			catch (Exception ex)
			{
				VRMod.StaticLogger.LogWarning((object)("[VR input] Could not list Rewired actions: " + ex.Message));
			}
		}

		internal static CustomControllerMap CreateUIMap(int controllerID)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Expected O, but got Unknown
			LogActions();
			List<ActionElementMap> list = new List<ActionElementMap>
			{
				new ActionElementMap(11, (ControllerElementType)1, 24, (Pole)0, (AxisRange)1, false),
				new ActionElementMap(12, (ControllerElementType)0, 4, (Pole)0, (AxisRange)0, false),
				new ActionElementMap(13, (ControllerElementType)0, 5, (Pole)0, (AxisRange)0, false),
				new ActionElementMap(14, (ControllerElementType)1, 17, (Pole)0, (AxisRange)1, false),
				new ActionElementMap(15, (ControllerElementType)1, 18, (Pole)0, (AxisRange)1, false),
				new ActionElementMap(25, (ControllerElementType)1, 24, (Pole)0, (AxisRange)1, false),
				new ActionElementMap(31, (ControllerElementType)1, 19, (Pole)0, (AxisRange)1, false),
				new ActionElementMap(43, (ControllerElementType)1, 32, (Pole)0, (AxisRange)1, false)
			};
			int pageLeft = ResolveActionId("UIPageLeft", 41);
			int pageRight = ResolveActionId("UIPageRight", 42);
			if (!list.Any((ActionElementMap m) => m.actionId == pageLeft && m.elementIdentifierId == 20))
			{
				list.Add(new ActionElementMap(pageLeft, (ControllerElementType)1, 20, (Pole)0, (AxisRange)1, false));
			}
			if (!list.Any((ActionElementMap m) => m.actionId == pageRight && m.elementIdentifierId == 21))
			{
				list.Add(new ActionElementMap(pageRight, (ControllerElementType)1, 21, (Pole)0, (AxisRange)1, false));
			}
			VRMod.StaticLogger.LogInfo((object)$"[VR input] Menu page navigation bound to the triggers: UIPageLeft=action {pageLeft} (left trigger), UIPageRight=action {pageRight} (right trigger).");
			return CreateCustomMap("VRUI", 2, controllerID, list);
		}

		internal static CustomControllerMap CreateGameplayMap(int controllerID)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Expected O, but got Unknown
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Expected O, but got Unknown
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected O, but got Unknown
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Expected O, but got Unknown
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Expected O, but got Unknown
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Expected O, but got Unknown
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Expected O, but got Unknown
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Expected O, but got Unknown
			List<ActionElementMap> actionElementMaps = new List<ActionElementMap>
			{
				new ActionElementMap(0, (ControllerElementType)0, 0, (Pole)0, (AxisRange)0, false),
				new ActionElementMap(1, (ControllerElementType)0, 1, (Pole)0, (AxisRange)0, false),
				new ActionElementMap(16, (ControllerElementType)0, 2, (Pole)0, (AxisRange)0, false),
				new ActionElementMap(17, (ControllerElementType)0, 3, (Pole)0, (AxisRange)0, false),
				new ActionElementMap(4, (ControllerElementType)1, 7, (Pole)0, (AxisRange)0, false),
				new ActionElementMap(5, (ControllerElementType)1, 6, (Pole)0, (AxisRange)0, false),
				new ActionElementMap(6, (ControllerElementType)1, 12, (Pole)0, (AxisRange)0, false),
				new ActionElementMap(7, (ControllerElementType)1, ModConfig.LeftDominantHand.Value ? 9 : 8, (Pole)0, (AxisRange)0, false),
				new ActionElementMap(8, (ControllerElementType)1, ModConfig.LeftDominantHand.Value ? 8 : 9, (Pole)0, (AxisRange)0, false),
				new ActionElementMap(9, (ControllerElementType)1, ModConfig.LeftDominantHand.Value ? 11 : 10, (Pole)0, (AxisRange)0, false),
				new ActionElementMap(10, (ControllerElementType)1, ModConfig.LeftDominantHand.Value ? 10 : 11, (Pole)0, (AxisRange)0, false),
				new ActionElementMap(18, (ControllerElementType)1, 13, (Pole)0, (AxisRange)0, false),
				new ActionElementMap(19, (ControllerElementType)1, 15, (Pole)0, (AxisRange)0, false),
				new ActionElementMap(28, (ControllerElementType)1, 14, (Pole)0, (AxisRange)0, false),
				new ActionElementMap(100, (ControllerElementType)1, 26, (Pole)0, (AxisRange)0, false),
				new ActionElementMap(101, (ControllerElementType)1, 27, (Pole)0, (AxisRange)0, false),
				new ActionElementMap(102, (ControllerElementType)1, 28, (Pole)0, (AxisRange)0, false),
				new ActionElementMap(103, (ControllerElementType)1, 29, (Pole)0, (AxisRange)0, false),
				new ActionElementMap(351, (ControllerElementType)1, 30, (Pole)0, (AxisRange)0, false),
				new ActionElementMap(400, (ControllerElementType)1, 31, (Pole)0, (AxisRange)0, false)
			};
			return CreateCustomMap("VRDefault", 0, controllerID, actionElementMaps);
		}

		private static CustomControllerMap CreateCustomMap(string mapName, int categoryId, int controllerId, List<ActionElementMap> actionElementMaps)
		{
			//IL_005e: 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_0081: 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)
			ReInput.UserData.CreateCustomControllerMap(categoryId, controllerId, 0);
			ControllerMap_Editor val = ReInput.UserData.customControllerMaps.Last();
			val.name = mapName;
			foreach (ActionElementMap actionElementMap2 in actionElementMaps)
			{
				val.AddActionElementMap();
				ActionElementMap actionElementMap = val.GetActionElementMap(val.ActionElementMaps.Count() - 1);
				actionElementMap.actionId = actionElementMap2.actionId;
				actionElementMap.JlvihEPEeXVJDZYBIPknxzyGpKJF(actionElementMap2.elementType);
				actionElementMap.elementIdentifierId = actionElementMap2.elementIdentifierId;
				actionElementMap.axisContribution = actionElementMap2.axisContribution;
				if ((int)actionElementMap2.elementType == 0)
				{
					actionElementMap.axisRange = actionElementMap2.axisRange;
				}
				actionElementMap.invert = actionElementMap2.invert;
			}
			return ReInput.UserData.kxLAVoHIxZMRJkGWhlwcKYnRDUeK(categoryId, controllerId, 0);
		}
	}
	internal static class SettingsTabs
	{
		private static bool leftWasPressed;

		private static bool rightWasPressed;

		private static bool loggedOnce;

		internal static void Poll()
		{
			bool num = GripPressed((XRNode)4);
			bool flag = GripPressed((XRNode)5);
			bool flag2 = num && !leftWasPressed;
			bool flag3 = flag && !rightWasPressed;
			leftWasPressed = num;
			rightWasPressed = flag;
			if (!flag2 && !flag3)
			{
				return;
			}
			try
			{
				HGHeaderNavigationController val = FindActiveTabs();
				if (!Object.op_Implicit((Object)(object)val))
				{
					return;
				}
				if (flag2)
				{
					val.MoveHeaderLeft();
				}
				else
				{
					val.MoveHeaderRight();
				}
				if (!loggedOnce)
				{
					loggedOnce = true;
					string arg = ((val.headers != null) ? string.Join(", ", val.headers.ConvertAll((Header h) => h.headerName).ToArray()) : "?");
					VRMod.StaticLogger.LogInfo((object)string.Format("[VR input] Settings tab moved {0} with the grip; now on index {1} of [{2}].", flag2 ? "left" : "right", val.currentHeaderIndex, arg));
				}
			}
			catch (Exception ex)
			{
				VRMod.StaticLogger.LogWarning((object)("[VR input] Settings tab switch failed: " + ex.Message));
			}
		}

		private static HGHeaderNavigationController FindActiveTabs()
		{
			if (Object.FindObjectsOfType<CharacterSelectController>().Any((CharacterSelectController c) => Object.op_Implicit((Object)(object)c) && ((Behaviour)c).isActiveAndEnabled))
			{
				return null;
			}
			return ((IEnumerable<HGHeaderNavigationController>)Object.FindObjectsOfType<HGHeaderNavigationController>()).FirstOrDefault((Func<HGHeaderNavigationController, bool>)((HGHeaderNavigationController c) => Object.op_Implicit((Object)(object)c) && ((Behaviour)c).isActiveAndEnabled && c.headers != null && c.headers.Count > 1));
		}

		private static bool GripPressed(XRNode node)
		{
			//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_0012: Unknown result type (might be due to invalid IL or missing references)
			InputDevice deviceAtXRNode = InputDevices.GetDeviceAtXRNode(node);
			bool flag = default(bool);
			return ((InputDevice)(ref deviceAtXRNode)).isValid && ((InputDevice)(ref deviceAtXRNode)).TryGetFeatureValue(CommonUsages.gripButton, ref flag) && flag;
		}
	}
	internal static class CutsceneFixes
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Start <0>__SetupIntro;

			public static hook_OnEnable <1>__SetupOutro;

			public static Action <2>__UpdateShipShot;

			public static Action <3>__KeepSkipPromptVisible;
		}

		private static Transform shipShot;

		private static bool introSkipPrevPressed;

		private static Transform introSkipGroup;

		private static bool introSkipSilenced;

		private static TMP_SpriteAsset introGlyphSheet;

		internal static void Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			object obj = <>O.<0>__SetupIntro;
			if (obj == null)
			{
				hook_Start val = SetupIntro;
				<>O.<0>__SetupIntro = val;
				obj = (object)val;
			}
			StartEvent.Start += (hook_Start)obj;
			object obj2 = <>O.<1>__SetupOutro;
			if (obj2 == null)
			{
				hook_OnEnable val2 = SetupOutro;
				<>O.<1>__SetupOutro = val2;
				obj2 = (object)val2;
			}
			OutroCutsceneController.OnEnable += (hook_OnEnable)obj2;
		}

		private static void SetupOutro(orig_OnEnable orig, OutroCutsceneController self)
		{
			GameObject val = GameObject.Find("CutsceneEnabledObjects");
			if (Object.op_Implicit((Object)(object)val))
			{
				Transform val2 = val.transform.Find("Camera Matcher/Menu Main Camera");
				if (Object.op_Implicit((Object)(object)val2))
				{
					CameraRigController component = ((Component)val2).GetComponent<CameraRigController>();
					GameObject[] allGameObjects = Resources.FindObjectsOfTypeAll<GameObject>();
					FixOutroCanvas(allGameObjects, component);
					AdjustOutroElements(allGameObjects, component);
				}
			}
			orig.Invoke(self);
		}

		private static void AdjustOutroElements(GameObject[] allGameObjects, CameraRigController cameraRig)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = allGameObjects.First((GameObject x) => ((Object)x).name == "Set 2 - Space");
			if (Object.op_Implicit((Object)(object)val))
			{
				val.transform.Translate(20f, 0f, 0f);
				Transform val2 = val.transform.Find("Dropship, Space");
				if (Object.op_Implicit((Object)(object)val2))
				{
					val2.localScale = Vector3.one;
				}
			}
		}

		private static void FixOutroCanvas(GameObject[] allGameObjects, CameraRigController cameraRig)
		{
			//IL_006b: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: 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)
			GameObject val = allGameObjects.First((GameObject x) => ((Object)x).name == "Set 5 - Canvas");
			if (Object.op_Implicit((Object)(object)val))
			{
				Canvas component = val.GetComponent<Canvas>();
				component.renderMode = (RenderMode)2;
				Transform transform = val.transform;
				Transform obj = ((transform is RectTransform) ? transform : null);
				obj.SetParent(((Component)cameraRig.sceneCam).transform);
				obj.localScale = new Vector3(0.01f, 0.01f, 0.01f);
				((RectTransform)obj).sizeDelta = new Vector2(6000f, 5000f);
				obj.localRotation = Quaternion.identity;
				obj.localPosition = new Vector3(0f, 0f, 15f);
				Transform transform2 = ((Component)val.GetComponentInChildren<OutroFlavorTextController>()).transform;
				Transform obj2 = ((transform2 is RectTransform) ? transform2 : null);
				((RectTransform)obj2).anchorMin = new Vector2(0.42f, 0.42f);
				((RectTransform)obj2).anchorMax = new Vector2(0.58f, 0.58f);
				((Component)obj2).gameObject.AddComponent<SmoothHUD>().Init(((Component)component.worldCamera).transform);
			}
		}

		private static void SetupIntro(orig_Start orig, StartEvent self)
		{
			orig.Invoke(self);
			IntroCutsceneController introController = ((Component)self).GetComponent<IntroCutsceneController>();
			if ((Object)(object)introController != (Object)null)
			{
				introSkipPrevPressed = false;
				Action skipPoll = null;
				skipPoll = delegate
				{
					//IL_001a: Unknown result type (might be due to invalid IL or missing references)
					//IL_001f: Unknown result type (might be due to invalid IL or missing references)
					//IL_002d: Unknown result type (might be due to invalid IL or missing references)
					if (!Object.op_Implicit((Object)(object)introController))
					{
						RoR2Application.onUpdate -= skipPoll;
					}
					else
					{
						InputDevice deviceAtXRNode = InputDevices.GetDeviceAtXRNode((XRNode)4);
						bool flag = false;
						if (((InputDevice)(ref deviceAtXRNode)).isValid)
						{
							((InputDevice)(ref deviceAtXRNode)).TryGetFeatureValue(CommonUsages.secondaryButton, ref flag);
						}
						if (flag && !introSkipPrevPressed)
						{
							IntroCutsceneController.shouldSkip = true;
							RoR2Application.onUpdate -= skipPoll;
						}
						introSkipPrevPressed = flag;
					}
				};
				RoR2Application.onUpdate += skipPoll;
			}
			if (!((Object)(object)introController != (Object)null))
			{
				return;
			}
			RoR2Application.onNextUpdate += delegate
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_018a: 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_0229: Unknown result type (might be due to invalid IL or missing references)
				//IL_022e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0272: Unknown result type (might be due to invalid IL or missing references)
				//IL_029e: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = GameObject.Find("Menu Main Camera");
				if (Object.op_Implicit((Object)(object)val))
				{
					Transform transform = val.transform;
					transform.localScale /= 6f;
					CameraRigController component = val.GetComponent<CameraRigController>();
					Vector3 position = new Vector3(-0.3387751f, 0.1797891f, -0.5321155f) * 5f / 6f;
					if (ModConfig.InitialRoomscaleValue)
					{
						position.y -= 0.3f;
					}
					component.desiredCameraState = new CameraState
					{
						position = position,
						rotation = Quaternion.Euler(3.899f, -180f, 0f)
					};
					component.currentCameraState = component.desiredCameraState;
					Object.Destroy((Object)(object)((Component)component.sceneCam).GetComponent<MatchCamera>());
					Transform parent = ((Component)component.sceneCam).transform.parent;
					GameObject val2 = Object.Instantiate<GameObject>(((Component)component.sceneCam).gameObject, parent.position, parent.rotation, parent);
					Object.Destroy((Object)(object)((Component)component.sceneCam).gameObject);
					Camera component2 = val2.GetComponent<Camera>();
					component2.cullingMask &= ~(1 << LayerIndex.ui.intVal);
					component.sceneCam = component2;
					ManualLogSource staticLogger = VRMod.StaticLogger;
					object[] obj = new object[5]
					{
						((Object)component2).name,
						null,
						null,
						null,
						null
					};
					Transform parent2 = ((Component)component2).transform.parent;
					obj[1] = ((parent2 != null) ? ((Object)parent2).name : null);
					Transform parent3 = ((Component)component2).transform.parent;
					obj[2] = ((parent3 != null) ? new Vector3?(parent3.lossyScale) : ((Vector3?)null));
					obj[3] = (Object.op_Implicit((Object)(object)component.uiCam) ? ((Object)component.uiCam).name : "null");
					object obj2;
					if (!Object.op_Implicit((Object)(object)component.uiCam))
					{
						obj2 = "-";
					}
					else
					{
						Transform parent4 = ((Component)component.uiCam).transform.parent;
						obj2 = ((parent4 != null) ? ((Object)parent4).name : null);
					}
					obj[4] = obj2;
					staticLogger.LogInfo((object)string.Format("[VR intro] scene cam '{0}' parent='{1}' (parent scale {2}); ui cam -> '{3}' parent='{4}'", obj));
					component.sprintingParticleSystem = val2.GetComponentInChildren<ParticleSystem>();
					if (Object.op_Implicit((Object)(object)parent))
					{
						parent.rotation = Quaternion.Euler(0f, ModConfig.IntroCameraYaw.Value, 0f) * parent.rotation;
					}
					if (!ModConfig.InitialRoomscaleValue && ModConfig.IntroSeatedHeightOffset.Value != 0f)
					{
						Vector3 localOffset = default(Vector3);
						((Vector3)(ref localOffset))..ctor(0f, ModConfig.IntroSeatedHeightOffset.Value, 0f);
						InsertOffsetParent(((Component)component2).transform, localOffset, "VR Intro Height (scene)");
						VRMod.StaticLogger.LogInfo((object)$"[VR intro] seated lift {ModConfig.IntroSeatedHeightOffset.Value} m applied (scene cam world y now {((Component)component2).transform.position.y:F3}).");
					}
					if (Object.op_Implicit((Object)(object)CameraFixes.liv))
					{
						CameraFixes.liv.HMDCamera = component2;
					}
					try
					{
						FixIntroCanvas(component);
					}
					catch (Exception ex)
					{
						VRMod.StaticLogger.LogWarning((object)("FixIntroCanvas: intro canvas layout differs from expected, partial fix applied: " + ex.Message));
					}
					try
					{
						AdjustIntroElements();
					}
					catch (Exception ex2)
					{
						VRMod.StaticLogger.LogWarning((object)("AdjustIntroElements: intro scene layout differs from expected, partial fix applied: " + ex2.Message));
					}
				}
			};
		}

		private static void InsertOffsetParent(Transform target, Vector3 localOffset, string name)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_0015: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			Transform parent = target.parent;
			GameObject val = new GameObject(name);
			SceneManager.MoveGameObjectToScene(val, ((Component)target).gameObject.scene);
			val.transform.SetParent(parent, false);
			val.transform.localPosition = localOffset;
			val.transform.localRotation = Quaternion.identity;
			val.transform.localScale = Vector3.one;
			target.SetParent(val.transform, false);
		}

		private static void AdjustIntroElements()
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			GameObject[] source = Resources.FindObjectsOfTypeAll<GameObject>();
			GameObject val = ((IEnumerable<GameObject>)source).FirstOrDefault((Func<GameObject, bool>)((GameObject x) => ((Object)x).name == "cutscene intro"));
			GameObject val2 = ((IEnumerable<GameObject>)source).FirstOrDefault((Func<GameObject, bool>)((GameObject x) => ((Object)x).name == "Set 1 - Space"));
			if (Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)val2))
			{
				shipShot = val.transform;
				RoR2Application.onLateUpdate += UpdateShipShot;
				val2.transform.Rotate(Vector3.up, -60f);
			}
			GameObject val3 = ((IEnumerable<GameObject>)source).FirstOrDefault((Func<GameObject, bool>)((GameObject x) => ((Object)x).name == "Set 2 - Cabin"));
			if (Object.op_Implicit((Object)(object)val3))
			{
				Transform val4 = val3.transform.Find("CabinPosition");
				if (Object.op_Implicit((Object)(object)val4))
				{
					val4.localScale = Vector3.one * 20f;
				}
			}
			GameObject val5 = ((IEnumerable<GameObject>)source).FirstOrDefault((Func<GameObject, bool>)((GameObject x) => ((Object)x).name == "Set 3 - Space, Small Planet"));
			if (Object.op_Implicit((Object)(object)val5))
			{
				val5.transform.Rotate(Vector3.up, -60f);
			}
			GameObject val6 = ((IEnumerable<GameObject>)source).FirstOrDefault((Func<GameObject, bool>)((GameObject x) => ((Object)x).name == "Set 4 - Cargo"));
			if (Object.op_Implicit((Object)(object)val6))
			{
				Transform val7 = val6.transform.Find("PP");
				PostProcessVolume val8 = (Object.op_Implicit((Object)(object)val7) ? ((Component)val7).GetComponent<PostProcessVolume>() : null);
				if (Object.op_Implicit((Object)(object)val8) && Object.op_Implicit((Object)(object)val8.profile) && val8.profile.HasSettings<DepthOfField>())
				{
					val8.profile.RemoveSettings<DepthOfField>();
				}
			}
		}

		private static void UpdateShipShot()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.Find("cutscene intro");
			if (Object.op_Implicit((Object)(object)val) && (Object)(object)val.transform != (Object)(object)shipShot)
			{
				shipShot = val.transform;
			}
			if (Object.op_Implicit((Object)(object)shipShot))
			{
				if (shipShot.eulerAngles.y != 210f)
				{
					((Component)shipShot).transform.eulerAngles = new Vector3(0f, 210f, 0f);
				}
				if (shipShot.localScale.x <= 1f)
				{
					((Component)shipShot).transform.localScale = Vector3.one * 50f;
				}
			}
			else
			{
				RoR2Application.onLateUpdate -= UpdateShipShot;
			}
		}

		private static void FixIntroCanvas(CameraRigController cameraRig)
		{
			//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_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			Canvas val = null;
			Canvas[] array = Resources.FindObjectsOfTypeAll<Canvas>();
			foreach (Canvas val2 in array)
			{
				if (Object.op_Implicit((Object)(object)val2) && val2.isRootCanvas)
				{
					Scene scene = ((Component)val2).gameObject.scene;
					if (!(((Scene)(ref scene)).name != "intro") && !((Object)(object)((Component)val2).transform.Find("MainArea") == (Object)null))
					{
						val = val2;
						break;
					}
				}
			}
			if (!Object.op_Implicit((Object)(object)val))
			{
				VRMod.StaticLogger.LogWarning((object)"FixIntroCanvas: intro story canvas not found; the typed text will only show on the monitor.");
				DumpCanvases("intro (canvas not found)");
				return;
			}
			GameObject gameObject = ((Component)val).gameObject;
			gameObject.SetActive(true);
			val.renderMode = (RenderMode)2;
			val.worldCamera = cameraRig.uiCam;
			Transform transform = gameObject.transform;
			RectTransform val3 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if (Object.op_Implicit((Object)(object)val3))
			{
				val3.sizeDelta = new Vector2(1920f, 1080f);
				((Transform)val3).localScale = new Vector3(0.008f, 0.008f, 0.008f);
				val3.pivot = new Vector2(0.5f, 0.5f);
				((Transform)val3).rotation = ((Component)cameraRig.uiCam).transform.rotation;
				((Transform)val3).position = ((Component)cameraRig.uiCam).transform.position + ((Component)cameraRig.uiCam).transform.forward * 12.35f;
			}
			if (!Object.op_Implicit((Object)(object)gameObject.GetComponent<SmoothHUD>()))
			{
				gameObject.AddComponent<SmoothHUD>().Init(((Component)cameraRig.uiCam).transform);
			}
			int num = 0;
			Image[] componentsInChildren = gameObject.GetComponentsInChildren<Image>(true);
			foreach (Image val4 in componentsInChildren)
			{
				string name = ((Object)((Component)val4).gameObject).name;
				bool num2 = name == "Fade" || name.Contains("BlackBar") || name.Contains("Letterbox");
				bool flag = (Object)(object)val4.sprite == (Object)null && ((Graphic)val4).color.a > 0.01f;
				if (num2 || flag)
				{
					((Behaviour)val4).enabled = false;
					num++;
				}
			}
			VRMod.StaticLogger.LogInfo((object)$"FixIntroCanvas: intro story canvas moved to world space (typed text + subtitles visible in VR), hid {num} panel image(s).");
			Transform val5 = gameObject.transform.Find("SkipVoteOverlay/CanvasGroup");
			if (Object.op_Implicit((Object)(object)val5))
			{
				introSkipGroup = val5;
				introSkipSilenced = false;
				RoR2Application.onUpdate += KeepSkipPromptVisible;
			}
		}

		private static void KeepSkipPromptVisible()
		{
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)introSkipGroup))
			{
				RoR2Application.onUpdate -= KeepSkipPromptVisible;
				return;
			}
			try
			{
				Transform parent = introSkipGroup.parent;
				if (Object.op_Implicit((Object)(object)parent) && !((Component)parent).gameObject.activeSelf)
				{
					((Component)parent).gameObject.SetActive(true);
				}
				if (!((Component)introSkipGroup).gameObject.activeSelf)
				{
					((Component)introSkipGroup).gameObject.SetActive(true);
				}
				CanvasGroup component = ((Component)introSkipGroup).GetComponent<CanvasGroup>();
				if (Object.op_Implicit((Object)(object)component) && component.alpha < 1f)
				{
					component.alpha = 1f;
				}
				Transform val = introSkipGroup.Find("NakedButton");
				if (Object.op_Implicit((Object)(object)val) && !((Component)val).gameObject.activeSelf)
				{
					((Component)val).gameObject.SetActive(true);
				}
				Transform val2 = (Object.op_Implicit((Object)(object)parent) ? parent : introSkipGroup);
				if (!introSkipSilenced)
				{
					introSkipSilenced = true;
					StringBuilder stringBuilder = new StringBuilder("[VR intro] skip overlay tree:\n");
					Transform[] componentsInChildren = ((Component)val2).GetComponentsInChildren<Transform>(true);
					foreach (Transform val3 in componentsInChildren)
					{
						stringBuilder.Append("  ").Append(GetPath(val3, val2.parent)).Append(" active=")
							.Append(((Component)val3).gameObject.activeSelf)
							.Append(" :");
						Component[] components = ((Component)val3).GetComponents<Component>();
						foreach (Component val4 in components)
						{
							if (Object.op_Implicit((Object)(object)val4))
							{
								stringBuilder.Append(' ').Append(((object)val4).GetType().Name);
								FieldInfo field = ((object)val4).GetType().GetField("actionName", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
								if (field != null)
								{
									stringBuilder.Append("(").Append(field.GetValue(val4)).Append(")");
								}
								InputResponse val5 = (InputResponse)(object)((val4 is InputResponse) ? val4 : null);
								if (val5 != null && val5.inputActionNames != null)
								{
									stringBuilder.Append("(").Append(string.Join(",", val5.inputActionNames)).Append(")");
								}
							}
						}
						stringBuilder.Append('\n');
					}
					VRMod.StaticLogger.LogInfo((object)stringBuilder.ToString());
				}
				Behaviour[] componentsInChildren2 = ((Component)val2).GetComponentsInChildren<Behaviour>(true);
				foreach (Behaviour val6 in componentsInChildren2)
				{
					if (!Object.op_Implicit((Object)(object)val6))
					{
						continue;
					}
					string name = ((object)val6).GetType().Name;
					if (val6.enabled)
					{
						switch (name)
						{
						case "HGGamepadInputEvent":
						case "InputBindingDisplayController":
						case "InputResponse":
							val6.enabled = false;
							break;
						}
					}
					Button val7 = (Button)(object)((val6 is Button) ? val6 : null);
					if (val7 == null)
					{
						continue;
					}
					UnityEvent onClick = (UnityEvent)(object)val7.onClick;
					for (int k = 0; k < ((UnityEventBase)onClick).GetPersistentEventCount(); k++)
					{
						if ((int)((UnityEventBase)onClick).GetPersistentListenerState(k) != 0)
						{
							((UnityEventBase)onClick).SetPersistentListenerState(k, (UnityEventCallState)0);
						}
					}
				}
				if (!Object.op_Implicit((Object)(object)introGlyphSheet))
				{
					introGlyphSheet = VRMod.VRAssetBundle.LoadAsset<TMP_SpriteAsset>("sprVRGlyphs");
				}
				string text = ControllerGlyphs.GetGlyph(24u);
				if (string.IsNullOrEmpty(text))
				{
					text = "<sprite name=\"texVRGlyphs_LSecondary\">";
				}
				TMP_Text[] componentsInChildren3 = ((Component)val2).GetComponentsInChildren<TMP_Text>(true);
				foreach (TMP_Text val8 in componentsInChildren3)
				{
					if (Object.op_Implicit((Object)(object)val8) && ((Object)((Component)val8).gameObject).name.IndexOf("Glyph", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						if (Object.op_Implicit((Object)(object)introGlyphSheet) && (Object)(object)val8.spriteAsset != (Object)(object)introGlyphSheet)
						{
							val8.spriteAsset = introGlyphSheet;
						}
						if (!val8.richText)
						{
							val8.richText = true;
						}
						if (val8.text != text)
						{
							val8.text = text;
						}
					}
				}
			}
			catch (Exception ex)
			{
				VRMod.StaticLogger.LogWarning((object)("[VR intro] skip prompt: " + ex.Message));
				RoR2Application.onUpdate -= KeepSkipPromptVisible;
			}
		}

		internal static void DumpCanvases(string context)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Canvas[] array = Resources.FindObjectsOfTypeAll<Canvas>();
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine(string.Format("[VR ui-dump] {0}: xrActive={1} mainCam={2}", context, XRSettings.isDeviceActive, Object.op_Implicit((Object)(object)Camera.main) ? ((Object)Camera.main).name : "none"));
				Canvas[] array2 = array;
				foreach (Canvas val in array2)
				{
					if (!Object.op_Implicit((Object)(object)val))
					{
						continue;
					}
					Scene scene = ((Component)val).gameObject.scene;
					if (((Scene)(ref scene)).name == null || !val.isRootCanvas)
					{
						continue;
					}
					object[] obj = new object[10]
					{
						GetPath(((Component)val).transform),
						((Behaviour)val).isActiveAndEnabled,
						val.renderMode,
						Object.op_Implicit((Object)(object)val.worldCamera) ? ((Object)val.worldCamera).name : "none",
						null,
						null,
						null,
						null,
						null,
						null
					};
					scene = ((Component)val).gameObject.scene;
					obj[4] = ((Scene)(ref scene)).name;
					obj[5] = val.sortingOrder;
					obj[6] = LayerMask.LayerToName(((Component)val).gameObject.layer);
					obj[7] = ((Component)val).transform.position;
					obj[8] = ((Component)val).transform.lossyScale;
					obj[9] = (Object.op_Implicit((Object)(object)((Component)val).transform.parent) ? ((Object)((Component)val).transform.parent).name : "-");
					stringBuilder.AppendLine(string.Format("  CANVAS '{0}' active={1} mode={2} cam={3} scene={4} sort={5} layer={6} pos={7} scale={8} parent={9}", obj));
					Graphic[] componentsInChildren = ((Component)val).GetComponentsInChildren<Graphic>(true);
					foreach (Graphic val2 in componentsInChildren)
					{
						string text = "";
						Image val3 = (Image)(object)((val2 is Image) ? val2 : null);
						if (val3 != null)
						{
							text = string.Format("sprite={0} color={1}", Object.op_Implicit((Object)(object)val3.sprite) ? ((Object)val3.sprite).name : "null", ((Graphic)val3).color);
						}
						else
						{
							RawImage val4 = (RawImage)(object)((val2 is RawImage) ? val2 : null);
							if (val4 != null)
							{
								text = "tex=" + (Object.op_Implicit((Object)(object)val4.texture) ? ((Object)val4.texture).name : "null");
							}
							else
							{
								TMP_Text val5 = (TMP_Text)(object)((val2 is TMP_Text) ? val2 : null);
								if (val5 != null)
								{
									text = "text=\"" + Truncate(val5.text) + "\"";
								}
								else
								{
									Text val6 = (Text)(object)((val2 is Text) ? val2 : null);
									if (val6 != null)
									{
										text = "text=\"" + Truncate(val6.text) + "\"";
									}
								}
							}
						}
						Transform transform = ((Component)val2).transform;
						RectTransform val7 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
						object[] obj2 = new object[7]
						{
							((object)val2).GetType().Name,
							GetPath(((Component)val2).transform, ((Component)val).transform),
							((Behaviour)val2).enabled,
							((Component)val2).gameObject.activeInHierarchy,
							null,
							null,
							null
						};
						Rect rect = val7.rect;
						obj2[4] = ((Rect)(ref rect)).size;
						obj2[5] = ((Transform)val7).position;
						obj2[6] = text;
						stringBuilder.AppendLine(string.Format("    {0} '{1}' on={2} activeInHier={3} rect={4} worldPos={5} {6}", obj2));
					}
				}
				VRMod.StaticLogger.LogInfo((object)stringBuilder.ToString());
			}
			catch (Exception arg)
			{
				VRMod.StaticLogger.LogWarning((object)$"DumpCanvases failed: {arg}");
			}
		}

		private static string Truncate(string t)
		{
			if (string.IsNullOrEmpty(t))
			{
				return "";
			}
			t = t.Replace("\n", "\\n");
			if (t.Length <= 60)
			{
				return t;
			}
			return t.Substring(0, 60) + "...";
		}

		private static string GetPath(Transform t, Transform stopAt = null)
		{
			string text = ((Object)t).name;
			while ((Object)(object)t.parent != (Object)null && (Object)(object)t.parent != (Object)(object)stopAt)
			{
				t = t.parent;
				text = ((Object)t).name + "/" + text;
			}
			return text;
		}

		internal static void ScheduleDumps(string context)
		{
			float start = Time.realtimeSinceStartup;
			int done = 0;
			float[] at = new float[4] { 1f, 3f, 6f, 10f };
			Action tick = null;
			tick = delegate
			{
				if (done >= at.Length)
				{
					RoR2Application.onUpdate -= tick;
				}
				else if (Time.realtimeSinceStartup - start >= at[done])
				{
					DumpCanvases($"{context} +{at[done]}s");
					done++;
				}
			};
			RoR2Application.onUpdate += tick;
		}
	}
	internal class FocusChecker : MonoBehaviour
	{
		private class HeadFollower : MonoBehaviour
		{
			internal Transform head;

			private const float Distance = 6f;

			private const float PitchDown = 25f;

			private void LateUpdate()
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				if (Object.op_Implicit((Object)(object)head))
				{
					Quaternion val = Quaternion.LookRotation(head.forward, Vector3.up) * Quaternion.Euler(25f, 0f, 0f);
					((Component)this).transform.position = head.position + val * Vector3.forward * 6f;
					((Component)this).transform.rotation = val;
				}
			}
		}

		internal static FocusChecker instance;

		private const float ShowDelaySeconds = 2f;

		private Canvas focusCanvas;

		private float unfocusedSince = -1f;

		private bool focused = true;

		private HeadFollower follower;

		internal static void Init()
		{
			RoR2Application.onLoad = (Action)Delegate.Combine(RoR2Application.onLoad, (Action)delegate
			{
				((Component)RoR2Application.instance).gameObject.AddComponent<FocusChecker>();
			});
		}

		private void Awake()
		{
			instance = this;
			focused = Application.isFocused;
			if (!focused)
			{
				unfocusedSince = Time.unscaledTime;
			}
		}

		private void OnApplicationFocus(bool hasFocus)
		{
			focused = hasFocus;
			if (hasFocus)
			{
				unfocusedSince = -1f;
				if (Object.op_Implicit((Object)(object)focusCanvas))
				{
					((Component)focusCanvas).gameObject.SetActive(false);
				}
			}
			else
			{
				unfocusedSince = Time.unscaledTime;
			}
		}

		private void Update()
		{
			if (!ModConfig.ShowUnfocusedWarning.Value)
			{
				if (Object.op_Implicit((Object)(object)focusCanvas) && ((Component)focusCanvas).gameObject.activeSelf)
				{
					((Component)focusCanvas).gameObject.SetActive(false);
				}
			}
			else
			{
				if (focused || unfocusedSince < 0f || Time.unscaledTime - unfocusedSince < 2f)
				{
					return;
				}
				if (!Object.op_Implicit((Object)(object)focusCanvas))
				{
					try
					{
						CreateCanvas();
					}
					catch (Exception ex)
					{
						VRMod.StaticLogger.LogWarning((object)("[VR focus] Could not build the unfocused warning: " + ex.Message));
						unfocusedSince = -1f;
						return;
					}
				}
				if (Object.op_Implicit((Object)(object)focusCanvas) && !((Component)focusCanvas).gameObject.activeSelf)
				{
					((Component)focusCanvas).gameObject.SetActive(true);
				}
			}
		}

		private void CreateCanvas()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_00c1: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: 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_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("VRFocusWarningCanvas");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.layer = LayerIndex.ui.intVal;
			focusCanvas = val.AddComponent<Canvas>();
			focusCanvas.renderMode = (RenderMode)2;
			focusCanvas.sortingOrder = 30000;
			Transform transform = val.transform;
			Transform obj = ((transform is RectTransform) ? transform : null);
			((RectTransform)obj).sizeDelta = new Vector2(1200f, 220f);
			obj.localScale = Vector3.one * 0.003f;
			GameObject val2 = new GameObject("Panel");
			val2.transform.SetParent(val.transform, false);
			val2.layer = val.layer;
			Image obj2 = val2.AddComponent<Image>();
			((Graphic)obj2).color = new Color(0.05f, 0.05f, 0.07f, 0.85f);
			Stretch(((Graphic)obj2).rectTransform, Vector2.zero, Vector2.zero);
			GameObject val3 = new GameObject("Outline");
			val3.transform.SetParent(val2.transform, false);
			val3.layer = val.layer;
			Image val4 = val3.AddComponent<Image>();
			((Graphic)val4).color = new Color(1f, 1f, 1f, 0f);
			Outline obj3 = val3.AddComponent<Outline>();
			((Shadow)obj3).effectColor = new Color(1f, 0.85f, 0.4f, 0.9f);
			((Shadow)obj3).effectDistance = new Vector2(3f, -3f);
			Stretch(((Graphic)val4).rectTransform, Vector2.zero, Vector2.zero);
			GameObject val5 = new GameObject("Text");
			val5.transform.SetParent(val2.transform, false);
			val5.layer = val.layer;
			TextMeshProUGUI val6 = val5.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val6).text = "<b>GAME WINDOW NOT FOCUSED</b>\nClick the Risk of Rain 2 window on your monitor to get control back.";
			((TMP_Text)val6).fontSize = 44f;
			((TMP_Text)val6).alignment = (TextAlignmentOptions)514;
			((Graphic)val6).color = new Color(1f, 0.92f, 0.75f, 1f);
			((TMP_Text)val6).enableWordWrapping = true;
			Stretch(((TMP_Text)val6).rectTransform, new Vector2(30f, 20f), new Vector2(-30f, -20f));
			TMP_Text val7 = null;
			if (Object.op_Implicit((Object)(object)RoR2Application.instance) && Object.op_Implicit((Object)(object)RoR2Application.instance.mainCanvas))
			{
				val7 = ((IEnumerable<TMP_Text>)((Component)RoR2Application.instance.mainCanvas).GetComponentsInChildren<TMP_Text>(true)).FirstOrDefault((Func<TMP_Text, bool>)((TMP_Text t) => Object.op_Implicit((Object)(object)t.font)));
			}
			if ((Object)(object)val7 == (Object)null)
			{
				val7 = ((IEnumerable<TMP_Text>)Resources.FindObjectsOfTypeAll<TMP_Text>()).FirstOrDefault((Func<TMP_Text, bool>)delegate(TMP_Text t)
				{
					//IL_0013: Unknown result type (might be due to invalid IL or missing references)
					//IL_0018: Unknown result type (might be due to invalid IL or missing references)
					if (Object.op_Implicit((Object)(object)t.font))
					{
						Scene scene = ((Component)t).gameObject.scene;
						return ((Scene)(ref scene)).name != null;
					}
					return false;
				});
			}
			if ((Object)(object)val7 != (Object)null)
			{
				((TMP_Text)val6).font = val7.font;
				if (Object.op_Implicit((Object)(object)val7.fontSharedMaterial))
				{
					((TMP_Text)val6).fontSharedMaterial = val7.fontSharedMaterial;
				}
			}
			follower = val.AddComponent<HeadFollower>();
			UpdateCameraRig(CameraRigController.instancesList.FirstOrDefault());
			VRMod.StaticLogger.LogInfo((object)"[VR focus] Unfocused warning shown (game window lost focus).");
		}

		private static void Stretch(RectTransform rt, Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = Vector2.zero;
			rt.anchorMax = Vector2.one;
			rt.offsetMin = offsetMin;
			rt.offsetMax = offsetMax;
		}

		internal void UpdateCameraRig(CameraRigController rig)
		{
			if (Object.op_Implicit((Object)(object)rig) && Object.op_Implicit((Object)(object)focusCanvas) && Object.op_Implicit((Object)(object)rig.uiCam))
			{
				focusCanvas.worldCamera = rig.uiCam;
				if (Object.op_Implicit((Object)(object)follower))
				{
					follower.head = ((Component)rig.uiCam).transform;
				}
			}
		}
	}
	internal static class Utils
	{
		private static CharacterMaster _localMaster;

		private static CharacterBody _localBody;

		private static CameraRigController _localCameraRig;

		private static Player _localInputPlayer;

		private static UserProfile _localUserProfile;

		internal static bool isUsingUI
		{
			get
			{
				if (Object.op_Implicit((Object)(object)Run.instance) && !PauseManager.isPaused && !MPEventSystemManager.primaryEventSystem.isCursorVisible)
				{
					return !Object.op_Implicit((Object)(object)MotionControls.currentBody);
				}
				return true;
			}
		}

		internal static CharacterMaster localMaster
		{
			get
			{
				if (!Object.op_Implicit((Object)(object)_localMaster))
				{
					LocalUser firstLocalUser = LocalUserManager.GetFirstLocalUser();
					if (firstLocalUser != null)
					{
						_localMaster = firstLocalUser.cachedMaster;
					}
				}
				return _localMaster;
			}
		}

		internal static CharacterBody localBody
		{
			get
			{
				if (!Object.op_Implicit((Object)(object)_localBody))
				{
					if (MotionControls.HandsReady)
					{
						_localBody = MotionControls.currentBody;
					}
					else
					{
						LocalUser firstLocalUser = LocalUserManager.GetFirstLocalUser();
						if (firstLocalUser != null)
						{
							_localBody = firstLocalUser.cachedBody;
						}
					}
				}
				return _localBody;
			}
		}

		internal static CameraRigController localCameraRig
		{
			get
			{
				if (!Object.op_Implicit((Object)(object)_localCameraRig) || !((Behaviour)_localCameraRig).isActiveAndEnabled)
				{
					_localCameraRig = ((IEnumerable<CameraRigController>)CameraRigController.instancesList).FirstOrDefault((Func<CameraRigController, bool>)((CameraRigController x) => ((Behaviour)x).isActiveAndEnabled));
				}
				return _localCameraRig;
			}
		}

		internal static Player localInputPlayer
		{
			get
			{
				if (_localInputPlayer == null)
				{
					LocalUser firstLocalUser = LocalUserManager.GetFirstLocalUser();
					if (firstLocalUser != null)
					{
						_localInputPlayer = firstLocalUser.inputPlayer;
					}
					if (_localInputPlayer == null)
					{
						_localInputPlayer = LocalUserManager.GetRewiredMainPlayer();
					}
				}
				return _localInputPlayer;
			}
		}

		internal static UserProfile localUserProfile
		{
			get
			{
				if (_localUserProfile == null)
				{
					LocalUser firstLocalUser = LocalUserManager.GetFirstLocalUser();
					if (firstLocalUser != null)
					{
						_localUserProfile = firstLocalUser.userProfile;
					}
				}
				return _localUserProfile;
			}
		}

		internal static void SetLayerRecursive(this GameObject obj, int layer)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			obj.layer = layer;
			foreach (Transform item in obj.transform)
			{
				((Component)item).gameObject.SetLayerRecursive(layer);
			}
		}

		internal static bool IsLocalBody(this CharacterBody body)
		{
			if (Object.op_Implicit((Object)(object)body))
			{
				return (Object)(object)body == (Object)(object)localBody;
			}
			return false;
		}

		internal static bool IsLocalMaster(this CharacterMaster master)
		{
			if (Object.op_Implicit((Object)(object)master))
			{
				return (Object)(object)master == (Object)(object)localMaster;
			}
			return false;
		}

		internal static Quaternion SmoothDamp(this Quaternion rot, Quaternion target, ref Quaternion deriv, float time)
		{
			//IL_000c: 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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: 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_008b: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: 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_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			if (Time.unscaledDeltaTime < Mathf.Epsilon)
			{
				return rot;
			}
			if (time == 0f)
			{
				return target;
			}
			float num = ((Quaternion.Dot(rot, target) > 0f) ? 1f : (-1f));
			target.x *= num;
			target.y *= num;
			target.z *= num;
			target.w *= num;
			Vector4 val = new Vector4(Mathf.SmoothDamp(rot.x, target.x, ref deriv.x, time, 2.1474836E+09f, Time.unscaledDeltaTime), Mathf.SmoothDamp(rot.y, target.y, ref deriv.y, time, 2.1474836E+09f, Time.unscaledDeltaTime), Mathf.SmoothDamp(rot.z, target.z, ref deriv.z, time, 2.1474836E+09f, Time.unscaledDeltaTime), Mathf.SmoothDamp(rot.w, target.w, ref deriv.w, time, 2.1474836E+09f, Time.unscaledDeltaTime));
			Vector4 normalized = ((Vector4)(ref val)).normalized;
			Vector4 val2 = Vector4.Project(new Vector4(deriv.x, deriv.y, deriv.z, deriv.w), normalized);
			deriv.x -= val2.x;
			deriv.y -= val2.y;
			deriv.z -= val2.z;
			deriv.w -= val2.w;
			return new Quaternion(normalized.x, normalized.y, normalized.z, normalized.w);
		}
	}
	[RequireComponent(typeof(Animator))]
	internal class EntityStateAnimationParameter : MonoBehaviour
	{
		internal enum EntityStateParameterType
		{
			IsInStateBool,
			OnStateEnterTrigger,
			OnStateExitTrigger
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static hook_SetState <0>__CheckStateMachine;
		}

		[SerializeField]
		private string[] stateNames;

		[SerializeField]
		private EntityStateParameterType parameterType;

		[SerializeField]
		private string parameterName;

		private static List<EntityStateAnimationParameter> instances;

		private CharacterBody body;

		private Animator animator;

		private EntityStateMachine[] bodyStateMachines;

		internal static void Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			object obj = <>O.<0>__CheckStateMachine;
			if (obj == null)
			{
				hook_SetState val = CheckStateMachine;
				<>O.<0>__CheckStateMachine = val;
				obj = (object)val;
			}
			EntityStateMachine.SetState += (hook_SetState)obj;
			instances = new List<EntityStateAnimationParameter>();
		}

		private static void CheckStateMachine(orig_SetState orig, EntityStateMachine self, EntityState newState)
		{
			if (self.commonComponents.characterBody.IsLocalBody())
			{
				foreach (EntityStateAnimationParameter instance in instances)
				{
					instance.DoUpdate(self, newState);
				}
			}
			orig.Invoke(self, newState);
		}

		private void OnEnable()
		{
			instances.Add(this);
		}

		private void OnDisable()
		{
			instances.Remove(this);
		}

		private void Awake()
		{
			body = MotionControls.currentBody;
			animator = ((Component)this).GetComponent<Animator>();
			if (!Object.op_Implicit((Object)(object)body) || !Object.op_Implicit((Object)(object)animator))
			{
				((Behaviour)this).enabled = false;
			}
			else
			{
				bodyStateMachines = ((Component)body).GetComponents<EntityStateMachine>();
			}
		}

		private void DoUpdate(EntityStateMachine stateMachine, EntityState newState)
		{
			if (!Object.op_Implicit((Object)(object)body) || !Object.op_Implicit((Object)(object)animator))
			{
				((Behaviour)this).enabled = false;
				return;
			}
			bool flag = stateNames.Contains(((object)stateMachine.state).GetType().Name);
			bool flag2 = stateNames.Contains(((object)newState).GetType().Name);
			if ((parameterType == EntityStateParameterType.OnStateEnterTrigger && flag2) || (parameterType == EntityStateParameterType.OnStateExitTrigger && flag))
			{
				animator.SetTrigger(parameterName);
			}
			else if (parameterType == EntityStateParameterType.IsInStateBool)
			{
				if (flag2)
				{
					animator.SetBool(parameterName, true);
				}
				else if (flag)
				{
					animator.SetBool(parameterName, false);
				}
			}
		}
	}
	internal class Hand : MonoBehaviour
	{
		[SerializeField]
		internal HandType handType;

		[SerializeField]
		internal Muzzle[] muzzles;

		[SerializeField]
		internal string bodyName;

		[SerializeField]
		internal bool useRay;

		[SerializeField]
		internal RendererInfo[] rendererInfos;

		[SerializeField]
		internal List<HandSkinDef> skins = new List<HandSkinDef>();

		[SerializeField]
		internal bool copyMaterialsFromCharacterModelIfNoSkin;

		internal Muzzle currentMuzzle;

		internal Animator animator { get; private set; }

		private void Awake()
		{
			animator = ((Component)this).GetComponent<Animator>();
			if (muzzles == null || muzzles.Length == 0)
			{
				throw new NullReferenceException("This hand has no muzzle! Aiming won't be possible that way and other errors may appear.");
			}
			currentMuzzle = muzzles[0];
		}

		private void OnEnable()
		{
			MotionControls.onSkinApplied = (MotionControls.SkinAppliedEventHandler)Delegate.Combine(MotionControls.onSkinApplied, new MotionControls.SkinAppliedEventHandler(ApplySkin));
		}

		private void OnDisable()
		{
			MotionControls.onSkinApplied = (MotionControls.SkinAppliedEventHandler)Delegate.Remove(MotionControls.onSkinApplied, new MotionControls.SkinAppliedEventHandler(ApplySkin));
		}

		internal void AddSkin(HandSkinDef skinDef)
		{
			if (skins.Contains(skinDef))
			{
				VRMod.StaticLogger.LogError((object)("The hand skin definition " + skinDef.originalSkinNameToken + " has already been added!"));
			}
			skins.Add(skinDef);
		}

		private void ApplySkin(SkinDef skinDef)
		{
			HandSkinDef handSkinDef = skins.FirstOrDefault((HandSkinDef x) => x.originalSkinNameToken == skinDef.nameToken);
			if ((Object)(object)handSkinDef != (Object)null)
			{
				handSkinDef.Apply(this);
			}
			else if (copyMaterialsFromCharacterModelIfNoSkin)
			{
				for (uint num = 0u; num < rendererInfos.Length; num++)
				{
					CopyMaterialFromModel(num);
				}
			}
		}

		internal void CopyMaterialFromModel(uint rendererInfoIndex)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: 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_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			CharacterModel component = ((Component)MotionControls.currentBody.modelLocator.modelTransform).GetComponent<CharacterModel>();
			RendererInfo rendererInfo = rendererInfos[rendererInfoIndex];
			string materialName = ((Object)rendererInfo.renderer.material).name;
			if (materialName.EndsWith(" (Instance)"))
			{
				materialName = materialName.Remove(materialName.IndexOf(" (Instance)"));
			}
			RendererInfo? val = ((IEnumerable<RendererInfo>)component.baseRendererInfos).FirstOrDefault((Func<RendererInfo, bool>)((RendererInfo x) => Object.op_Implicit((Object)(object)x.defaultMaterial) && (((Object)x.defaultMaterial).name.Replace(" (Instance)", "") == materialName || ((Object)x.defaultMaterial).name.Replace("Alt", "").Replace(" (Instance)", "") == materialName)));
			if (!val.HasValue || (Object)(object)val.Value.defaultMaterial == (Object)null)
			{
				if (!(rendererInfo.renderer is MeshRenderer) && !(rendererInfo.renderer is SkinnedMeshRenderer))
				{
					return;
				}
				val = ((IEnumerable<RendererInfo>)component.baseRendererInfos).FirstOrDefault((Func<RendererInfo, bool>)((RendererInfo x) => (x.renderer is MeshRenderer || x.renderer is SkinnedMeshRenderer) && ((Object)x.renderer).name == ((Object)rendererInfo.renderer).name));
				if (!val.HasValue)
				{
					return;
				}
			}
			RendererInfo value = val.Value;
			if (Object.op_Implicit((Object)(object)value.defaultMaterial))
			{
				VRMod.StaticLogger.LogInfo((object)("Applying body material " + ((Object)value.defaultMaterial).name + " on renderer " + ((Object)((Component)rendererInfo.renderer).gameObject).name));
				rendererInfo.renderer.material = value.defaultMaterial;
				rendererInfo.defaultMaterial = value.defaultMaterial;
				rendererInfos[rendererInfoIndex] = rendererInfo;
			}
			else
			{
				VRMod.StaticLogger.LogWarning((object)("No material replacement found for " + materialName + "."));
			}
		}
	}
	public enum HandType
	{
		Both,
		Dominant,
		NonDominant
	}
	[CreateAssetMenu(menuName = "VRMod/HandSkinDef")]
	public class HandSkinDef : ScriptableObject
	{
		[Serializable]
		public struct RendererInfoOverride
		{
			[Tooltip("The index of the renderer info to override. For indexes of vanilla characters, check out the RoR2VRMod wiki on GitHub.")]
			public uint rendererInfoIndex;

			[Tooltip("The new mesh that will replace the one stored in the associated renderer. Leave this field empty to keep the original mesh.")]
			public Mesh meshOverride;

			[Tooltip("The new material that will replace the one stored in the associated renderer. Leave this field empty to keep the original material.")]
			public Material materialOverride;

			[Tooltip("If enabled, the material override will be skipped and instead will attempt to copy the material from the character model by checking matching material or renderer object names. For this to work, the character needs a ModelLocator and a CharacterModel component.")]
			public bool copyMaterialFromCharacterModel;

			public ShadowCastingMode defaultShadowCastingMode;

			public bool ignoreOverlays;

			public bool hideOnDeath;
		}

		[Tooltip("The name of the character body prefab.")]
		public string characterBodyName;

		[Tooltip("The name token of the original character model skin. If your original skin uses KingEnderBrine's skin builder, write the token in full upper-case like so by replacing the spaces surrounded with \"*\": *SKINAUTHOR*_SKIN_*SKINDEFINITIONNAME*_NAME")]
		public string originalSkinNameToken;

		[Tooltip("The hand on which to apply the override.")]
		public HandType handType;

		public RendererInfoOverride[] rendererInfoOverrides;

		internal void Apply(Hand hand)
		{
			//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_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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: 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)
			for (int i = 0; i < rendererInfoOverrides.Length; i++)
			{
				RendererInfoOverride rendererInfoOverride = rendererInfoOverrides[i];
				if (rendererInfoOverride.rendererInfoIndex >= hand.rendererInfos.Length)
				{
					VRMod.StaticLogger.LogError((object)("The hand skin " + originalSkinNameToken + " is attempting to override a renderer info that doesn't exist!"));
					break;
				}
				RendererInfo val = hand.rendererInfos[rendererInfoOverride.rendererInfoIndex];
				val.defaultShadowCastingMode = rendererInfoOverride.defaultShadowCastingMode;
				val.ignoreOverlays = rendererInfoOverride.ignoreOverlays;
				val.hideOnDeath = rendererInfoOverride.hideOnDeath;
				hand.rendererInfos[rendererInfoOverride.rendererInfoIndex] = val;
				if (Object.op_Implicit((Object)(object)rendererInfoOverride.meshOverride))
				{
					if (val.renderer is SkinnedMeshRenderer)
					{
						Renderer renderer = val.renderer;
						((SkinnedMeshRenderer)((renderer is SkinnedMeshRenderer) ? renderer : null)).sharedMesh = rendererInfoOverride.meshOverride;
					}
					else if (val.renderer is MeshRenderer)
					{
						MeshFilter component = ((Component)val.renderer).GetComponent<MeshFilter>();
						if (Object.op_Implicit((Object)(object)component))
						{
							component.sharedMesh = rendererInfoOverride.meshOverride;
						}
					}
					else
					{
						VRMod.StaticLogger.LogError((object)("The hand skin " + originalSkinNameToken + " is attempting to override a mesh on a renderer that doesn't support meshes!"));
					}
				}
				if (rendererInfoOverride.copyMaterialFromCharacterModel)
				{
					hand.CopyMaterialFromModel(rendererInfoOverride.rendererInfoIndex);
				}
				else if (Object.op_Implicit((Object)(object)rendererInfoOverride.materialOverride))
				{
					val.defaultMaterial = rendererInfoOverride.materialOverride;
					hand.rendererInfos[rendererInfoOverride.rendererInfoIndex] = val;
				}
			}
		}
	}
	internal class MeleeSkill : MonoBehaviour
	{
		[SerializeField]
		private Transform weaponTip;

		[SerializeField]
		public float speedThreshold;

		[SerializeField]
		private string[] activatedSkills;

		[SerializeField]
		private float activationTime;

		internal static bool[] skillStates = new bool[4];

		private static float[] timers = new float[4];

		private static CharacterBody body;

		private static List<MeleeSkill> instanceList = new List<MeleeSkill>();

		private Vector3[] tipPath = (Vector3[])(object)new Vector3[3];

		private bool firstFrame = true;

		private void OnEnable()
		{
			if (instanceList.Count() <= 0)
			{
				RoR2Application.onFixedUpdate += UpdateTimer;
			}
			instanceList.Add(this);
		}

		private void OnDisable()
		{
			instanceList.Remove(this);
			if (instanceList.Count() <= 0)
			{
				RoR2Application.onFixedUpdate -= UpdateTimer;
			}
		}

		private static void UpdateTimer()
		{
			for (int i = 0; i < 4; i++)
			{
				if (timers[i] > 0f)
				{
					timers[i] -= Time.fixedDeltaTime;
				}
				skillStates[i] = timers[i] > 0f;
			}
		}

		private void FixedUpdate()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Invalid comparison between Unknown and I4
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)VRCameraWrapper.instance) || (!Object.op_Implicit((Object)(object)body) && (Object)(object)(body = LocalUserManager.GetFirstLocalUser().cachedBody) == (Object)null))
			{
				return;
			}
			Vector3 val = ((Component)VRCameraWrapper.instance).transform.InverseTransformPoint(((Component)weaponTip).transform.position);
			if (val != tipPath[0])
			{
				tipPath[2] = tipPath[1];
				tipPath[1] = tipPath[0];
				tipPath[0] = val;
				if (firstFrame)
				{
					firstFrame = false;
					tipPath[2] = (tipPath[1] = tipPath[0]);
				}
			}
			bool flag = Time.fixedDeltaTime * speedThreshold < Vector3.Distance(tipPath[0], tipPath[2]) / 2f;
			foreach (GenericSkill item in (from x in body.skillLocator.allSkills.ToList()
				where activatedSkills.ToList().Contains(x.skillName) || activatedSkills.ToList().Contains(x.skillDef.skillName)
				select x).ToList())
			{
				if (!item.skillDef.skillName.Contains("Lunar") || !item.skillDef.skillName.Contains("Replacement"))
				{
					SkillSlot val2 = body.skillLocator.FindSkillSlot(item);
					if ((int)val2 != -1 && flag)
					{
						timers[val2] = activationTime;
					}
				}
			}
		}
	}
	internal class Muzzle : MonoBehaviour
	{
		[SerializeField]
		internal string[] entriesToReplaceIfDominant;

		[SerializeField]
		internal string[] entriesToReplaceIfNonDominant;
	}
	[RequireComponent(typeof(Animator))]
	internal class SkillAnimationParameter : MonoBehaviour
	{
		internal enum ParameterType
		{
			OnExecuteTrigger,
			OnAvailableBool
		}

		[SerializeField]
		private string skillName;

		[SerializeField]
		private SkillSlot forceSkillSlot;

		[SerializeField]
		private ParameterType parameterType;

		[SerializeField]
		private string parameterName;

		private Animator animator;

		private GenericSkill associatedSkill;

		private bool foundSkill;

		private bool wasAvailable;

		private CharacterBody body;

		private void Start()
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Invalid comparison between Unknown and I4
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			body = MotionControls.currentBody;
			animator = ((Component)this).GetComponent<Animator>();
			if (!Object.op_Implicit((Object)(object)body) || !Object.op_Implicit((Object)(object)animator))
			{
				return;
			}
			if (parameterType == ParameterType.OnExecuteTrigger)
			{
				body.onSkillActivatedAuthority += OnActivatedAuthority;
				body.onSkillActivatedServer += OnActivatedServer;
				return;
			}
			if ((int)forceSkillSlot == -1)
			{
				associatedSkill = body.skillLocator.FindSkill(skillName);
				if (!Object.op_Implicit((Object)(object)associatedSkill))
				{
					associatedSkill = ((IEnumerable<GenericSkill>)body.skillLocator.allSkills.ToList()).FirstOrDefault((Func<GenericSkill, bool>)((GenericSkill x) => x.skillDef.skillName == skillName || SkillCatalog.GetSkillName(x.skillDef.skillIndex) == skillName));
				}
			}
			else
			{
				associatedSkill = body.skillLocator.GetSkill(forceSkillSlot);
			}
			if (Object.op_Implicit((Object)(object)associatedSkill))
			{
				foundSkill = true;
				RoR2Application.onLateUpdate += UpdateBool;
			}
		}

		private void OnDestroy()
		{
			if (parameterType == ParameterType.OnAvailableBool)
			{
				if (foundSkill)
				{
					RoR2Application.onLateUpdate -= UpdateBool;
				}
			}
			else if (Object.op_Implicit((Object)(object)body))
			{
				body.onSkillActivatedAuthority -= OnActivatedAuthority;
				body.onSkillActivatedServer -= OnActivatedServer;
			}
		}

		private void OnActivatedAuthority(GenericSkill skill)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (((int)forceSkillSlot == -1 || body.skillLocator.FindSkillSlot(skill) == forceSkillSlot) && (SkillCatalog.GetSkillName(skill.skillDef.skillIndex) == skillName || skill.skillDef.skillName == skillName))
			{
				animator.SetTrigger(parameterName);
			}
		}

		private void OnActivatedServer(GenericSkill skill)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (!body.hasEffectiveAuthority && ((int)forceSkillSlot == -1 || body.skillLocator.FindSkillSlot(skill) == forceSkillSlot) && (SkillCatalog.GetSkillName(skill.skillDef.skillIndex) == skillName || skill.skillDef.skillName == skillName))
			{
				animator.SetTrigger(parameterName);
			}
		}

		private void UpdateBool()
		{
			bool flag = (Object)(object)associatedSkill != (Object)null && (associatedSkill.skillDef.skillName == skillName || associatedSkill.skillName == skillName || SkillCatalog.GetSkillName(associatedSkill.skillDef.skillIndex) == skillName) && associatedSkill.stock > 0;
			if (flag != wasAvailable)
			{
				wasAvailable = flag;
				animator.SetBool(parameterName, flag);
			}
		}
	}
	internal class SniperScopeController : MonoBehaviour
	{
		[SerializeField]
		private Transform scopeCameraParent;

		[SerializeField]
		private RenderTexture scopeRenderTexture;

		[SerializeField]
		private MeshRenderer scopeViewRenderer;

		[SerializeField]
		private Canvas overlayCanvas;

		private Camera scopeCamera;

		private Camera scopeUICamera;

		private Material renderMaterial;

		private float targetFOV;

		private PointViewer pointViewer;

		private RenderTexture scopeUIRenderTexture;

		private static Material clearMaterial;

		private static Material uiTransparentMaterial;

		private void Awake()
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			UpdateDominance(ModConfig.LeftDominantHand.Value);
			renderMaterial = ((Renderer)scopeViewRenderer).material;
			if (!Object.op_Implicit((Object)(object)clearMaterial))
			{
				clearMaterial = VRMod.VRAssetBundle.LoadAsset<Material>("ScopeViewCleared");
			}
			if (!Object.op_Implicit((Object)(object)uiTransparentMaterial))
			{
				uiTransparentMaterial = VRMod.VRAssetBundle.LoadAsset<Material>("UnlitTransparentMat");
			}
			((Component)overlayCanvas).transform.SetParent((Transform)null);
			overlayCanvas.planeDistance = 12.5f;
			((Component)overlayCanvas).gameObject.SetLayerRecursive(LayerIndex.enemyBody.intVal);
			scopeUIRenderTexture = new RenderTexture(scopeRenderTexture);
			scopeUIRenderTexture.Create();
			((Renderer)scopeViewRenderer).material = clearMaterial;
			PointViewer.FindCamera += new hook_FindCamera(DidntAsk);
			PointViewer.UpdateAllElementPositions += new hook_UpdateAllElementPositions(ReplaceWithScopeCameras);
			PointViewer.AddElement += new hook_AddElement(ReplaceLayer);
			RoR2Application.onLateUpdate += FindAndInstantiateCamera;
		}

		private void FindAndInstantiateCamera()
		{
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Expected O, but got Unknown
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)Utils.localCameraRig) || !Object.op_Implicit((Object)(object)Utils.localCameraRig.hud))
			{
				return;
			}
			Camera sceneCam = Utils.localCameraRig.sceneCam;
			bool enabled = ((Behaviour)sceneCam).enabled;
			if (enabled)
			{
				((Behaviour)sceneCam).enabled = false;
			}
			bool activeSelf = ((Component)sceneCam).gameObject.activeSelf;
			if (activeSelf)
			{
				((Component)sceneCam).gameObject.SetActive(false);
			}
			scopeCamera = Object.Instantiate<GameObject>(((Component)sceneCam).gameObject, (Transform)null).GetComponent<Camera>();
			Component[] components = ((Component)scopeCamera).GetComponents<Component>();
			Object.Destroy((Object)(object)((Component)scopeCamera).GetComponent<OutlineHighlight>());
			Component[] array = components;
			foreach (Component val in array)
			{
				if (!(val is Transform) && !(val is Camera) && !(val is PostProcessLayer) && (!(val is SobelCommandBuffer) || val is DecaliciousRenderer))
				{
					Object.Destroy((Object)(object)val);
				}
			}
			scopeCamera.stereoTargetEye = (StereoTargetEyeMask)0;
			if (activeSelf != ((Component)sceneCam).gameObject.activeSelf)
			{
				((Component)sceneCam).gameObject.SetActive(activeSelf);
			}
			if (enabled != ((Behaviour)sceneCam).enabled)
			{
				((Behaviour)sceneCam).enabled = enabled;
			}
			((Component)scopeCamera).gameObject.SetActive(true);
			((Component)scopeCamera).transform.SetParent(scopeCameraParent);
			((Component)scopeCamera).transform.localPosition = Vector3.zero;
			((Component)scopeCamera).transform.localRotation = Quaternion.identity;
			scopeCamera.targetTexture = scopeRenderTexture;
			foreach (Transform item in ((Component)scopeCamera).transform)
			{
				Object.Destroy((Object)(object)((Component)item).gameObject);
			}
			GameObject val2 = new GameObject("Weakpoints Camera");
			val2.transform.SetParent(((Component)scopeCameraParent).transform);
			val2.transform.localPosition = Vector3.zero;
			val2.transform.localRotation = Quaternion.identity;
			val2.transform.localScale = Vector3.one;
			scopeUICamera = val2.AddComponent<Camera>();
			scopeUICamera.cullingMask = 1 << LayerIndex.enemyBody.intVal;
			scopeUICamera.clearFlags = (CameraClearFlags)2;
			scopeUICamera.backgroundColor = new Color(0f, 0f, 0f, 0f);
			scopeUICamera.rect = new Rect(0f, 0f, 1f, 1f);
			scopeUICamera.depth = 1f;
			scopeUICamera.stereoTargetEye = (StereoTargetEyeMask)0;
			scopeUICamera.allowHDR = false;
			scopeUICamera.allowMSAA = false;
			((Behaviour)scopeUICamera).enabled = false;
			scopeUICamera.fieldOfView = 80f;
			scopeUICamera.targetTexture = scopeUIRenderTexture;
			((Component)scopeUICamera).gameObject.SetActive(true);
			overlayCanvas.worldCamera = scopeUICamera;
			RoR2Application.onLateUpdate -= FindAndInstantiateCamera;
		}

		private void DidntAsk(orig_FindCamera orig, PointViewer self)
		{
			if ((Object)(object)self != (Object)(object)pointViewer)
			{
				orig.Invoke(self);
			}
		}

		private GameObject ReplaceLayer(orig_AddElement orig, PointViewer self, AddElementRequest request)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = orig.Invoke(self, request);
			if (Object.op_Implicit((Object)(object)val) && (Object)(object)self == (Object)(object)pointViewer)
			{
				val.SetLayerRecursive(LayerIndex.enemyBody.intVal);
			}
			return val;
		}

		private void ReplaceWithScopeCameras(orig_UpdateAllElementPositions orig, PointViewer self)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)self != (Object)(object)pointViewer || !Object.op_Implicit((Object)(object)scopeCamera))
			{
				orig.Invoke(self);
				return;
			}
			Rect rect = self.rectTransform.rect;
			Vector2 size = ((Rect)(ref rect)).size;
			float num = scopeCamera.fieldOfView * 0.054831136f;
			float num2 = 1f / num;
			Vector3 localPosition = default(Vector3);
			foreach (KeyValuePair<UnityObjectWrapperKey<GameObject>, Ptr<ElementInfo>> item in self.elementToElementInfo)
			{
				Ptr<ElementInfo> value = item.Value;
				ref ElementInfo reference = ref self.elementInfoAllocator.GetRef(value);
				if (Object.op_Implicit((Object)(object)reference.targetTransform))
				{
					reference.targetLastKnownPosition = reference.targetTransform.position;
				}
				Vector3 targetLastKnownPosition = reference.targetLastKnownPosition;
				targetLastKnownPosition.y += reference.targetWorldVerticalOffset;
				Vector3 val = scopeCamera.WorldToViewportPoint(targetLastKnownPosition);
				val.x -= 0.5f;
				val.y -= 0.5f;
				float z = val.z;
				Vector2 sizeDelta = self.rectTransform.sizeDelta;
				((Vector3)(ref localPosition))..ctor(val.x * sizeDelta.x, val.y * sizeDelta.y, 0f);
				localPosition.z = ((z >= 0f) ? 0f : (-1f));
				((Transform)reference.elementRectTransform).localPosition = localPosition;
				if (reference.scaleWithDistance)
				{
					float num3 = reference.targetWorldDiameter * num2 / z;
					reference.elementRectTransform.sizeDelta = num3 * size;
				}
			}
		}

		private void OnDestroy()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			scopeUIRenderTexture.Release();
			PointViewer.FindCamera -= new hook_FindCamera(DidntAsk);
			PointViewer.UpdateAllElementPositions -= new hook_UpdateAllElementPositions(ReplaceWithScopeCameras);
			PointViewer.AddElement -= new hook_AddElement(ReplaceLayer);
			Object.Destroy((Object)(object)overlayCanvas);
			if (!Object.op_Implicit((Object)(object)scopeCamera))
			{
				RoR2Application.onLateUpdate -= FindAndInstantiateCamera;
			}
		}

		private void OnEnable()
		{
			if (Object.op_Implicit((Object)(object)scopeCamera))
			{
				scopeCamera.fieldOfView = targetFOV;
				((Renderer)scopeViewRenderer).material = renderMaterial;
			}
		}

		private void OnDisable()
		{
			((Renderer)scopeViewRenderer).material = clearMaterial;
		}

		private void LateUpdate()
		{
			((MonoBehaviour)this).StartCoroutine(RenderScopeView());
		}

		private IEnumerator RenderScopeView()
		{
			yield return (object)new WaitForEndOfFrame();
			scopeCamera.Render();
			scopeUICamera.Render();
			Graphics.Blit((Texture)(object)scopeUIRenderTexture, scopeRenderTexture, uiTransparentMaterial);
		}

		internal void SetFOV(float fov)
		{
			targetFOV = fov;
			if (Object.op_Implicit((Object)(object)scopeCamera))
			{
				scopeCamera.fieldOfView = targetFOV;
			}
		}

		internal void UpdateDominance(bool leftHanded)
		{
			//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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			Vector3 localScale = ((Component)scopeViewRenderer).transform.localScale;
			if (localScale.x < 0f != leftHanded)
			{
				localScale.x = 0f - localScale.x;
			}
			((Component)scopeViewRenderer).transform.localScale = localScale;
		}

		internal void SetOverlay(GameObject overlay)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			overlay.transform.SetParent(((Component)overlayCanvas).transform);
			overlay.transform.localPosition = Vector3.zero;
			overlay.transform.localRotation = Quaternion.identity;
			overlay.transform.localScale = Vector3.one;
			overlay.SetLayerRecursive(LayerIndex.enemyBody.intVal);
			pointViewer = overlay.GetComponentInChildren<PointViewer>();
			? val = pointViewer.rectTransform;
			Transform transform = ((Component)overlayCanvas).transform;
			((RectTransform)val).sizeDelta = ((RectTransform)((transform is RectTransform) ? transform : null)).sizeDelta;
		}
	}
	internal class TwoHandedGuidingHand : MonoBehaviour
	{
		[SerializeField]
		internal Transform guidingTransform;

		[SerializeField]
		internal GameObject objectToDisableWhenTwoHanded;

		private HandController parentHand;

		private void Awake()
		{
			parentHand = ((Component)this).GetComponentInParent<HandController>();
		}

		private void OnDisable()
		{
			if (Object.op_Implicit((Object)(object)parentHand))
			{
				parentHand.stabilisePosition = false;
			}
		}

		private void Update()
		{
			bool flag = Object.op_Implicit((Object)(object)objectToDisableWhenTwoHanded) && !objectToDisableWhenTwoHanded.activeSelf;
			if (Object.op_Implicit((Object)(object)parentHand) && parentHand.stabilisePosition != flag)
			{
				parentHand.stabilisePosition = flag;
			}
		}
	}
	[RequireComponent(typeof(Hand))]
	public class TwoHandedMainHand : MonoBehaviour
	{
		[SerializeField]
		public bool twoHandedAimActive = true;

		[SerializeField]
		public float snapAngle = 40f;

		[SerializeField]
		private Transform guide;

		[SerializeField]
		private Transform objectToGuide;

		[SerializeField]
		private GameObject objectToEnableWhenTwoHanded;

		private bool isHandWithinRange;

		private TwoHandedGuidingHand targetHand;

		private Vector3 guidingVector;

		private Quaternion originalRotation;

		private HandController parentHand;

		private void Awake()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			parentHand = ((Component)this).GetComponentInParent<HandController>();
			originalRotation = objectToGuide.localRotation;
		}

		private void OnDisable()
		{
			if (Object.op_Implicit((Object)(object)parentHand))
			{
				parentHand.stabilisePosition = false;
			}
		}

		private void Update()
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			HandController componentInParent = ((Component)this).GetComponentInParent<HandController>();
			if (!Object.op_Implicit((Object)(object)targetHand))
			{
				if (Object.op_Implicit((Object)(object)componentInParent))
				{
					targetHand = ((Component)componentInParent.oppositeHand.currentHand).GetComponent<TwoHandedGuidingHand>();
				}
				if (!Object.op_Implicit((Object)(object)targetHand))
				{
					return;
				}
			}
			if (twoHandedAimActive && Object.op_Implicit((Object)(object)targetHand.guidingTransform))
			{
				guidingVector = targetHand.guidingTransform.position - guide.position;
				float num = Vector3.Angle(guide.forward, guidingVector);
				isHandWithinRange = num <= snapAngle;
			}
			else if (isHandWithinRange)
			{
				isHandWithinRange = false;
				objectToGuide.rotation = originalRotation;
			}
			if (isHandWithinRange)
			{
				objectToGuide.rotation = Quaternion.LookRotation(guidingVector, guide.up);
				if (!objectToEnableWhenTwoHanded.activeSelf)
				{
					objectToEnableWhenTwoHanded.SetActive(true);
					targetHand.objectToDisableWhenTwoHanded.SetActive(false);
				}
			}
			else
			{
				if (objectToGuide.localRotation != originalRotation)
				{
					objectToGuide.localRotation = originalRotation;
				}
				if (objectToEnableWhenTwoHanded.activeSelf)
				{
					objectToEnableWhenTwoHanded.SetActive(false);
					targetHand.objectToDisableWhenTwoHanded.SetActive(true);
				}
			}
			if (Object.op_Implicit((Object)(object)parentHand) && parentHand.stabilisePosition != isHandWithinRange)
			{
				parentHand.stabilisePosition = isHandWithinRange;
			}
		}
	}
	public class HandController : MonoBehaviour
	{
		[SerializeField]
		private LineRenderer ray;

		[SerializeField]
		private Hand pointerHand;

		[SerializeField]
		internal HandHUD smallHud;

		[SerializeField]
		internal HandHUD watchHud;

		internal XRNode xrNode;

		internal HandController oppositeHand;

		internal bool hasAimableEquipment;

		internal bool hasAimableHeresySkill;

		internal bool stabilisePosition;

		private Hand uiHand;

		private bool _uiMode;

		private Vector3 lastPosition;

		private Quaternion lastRotation;

		private List<GameObject> handPrefabs;

		private InputDevice inputDevice;

		public Animator animator => currentHand.animator;

		public Ray aimRay => new Ray(muzzle.position, muzzle.forward);

		public RendererInfo[] rendererInfos => currentHand.rendererInfos;

		internal Ray uiRay => new Ray(((Component)uiHand.currentMuzzle).transform.position, ((Component)uiHand.currentMuzzle).transform.forward);

		public Transform muzzle => ((Component)currentHand.currentMuzzle).transform;

		internal Hand currentHand { get; private set; }

		private bool rayActive
		{
			get
			{
				if (!uiMode)
				{
					if (!currentHand.useRay && !hasAimableHeresySkill)
					{
						if (hasAimableEquipment)
						{
							CharacterBody currentBody = MotionControls.currentBody;
							if (currentBody == null)
							{
								return false;
							}
							EquipmentSlot equipmentSlot = currentBody.equipmentSlot;
							return ((equipmentSlot != null) ? new int?(equipmentSlot.stock) : ((int?)null)) > 0;
						}
						return false;
					}
					return true;
				}
				return false;
			}
		}

		internal bool uiMode
		{
			get
			{
				return _uiMode;
			}
			set
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Invalid comparison between Unknown and I4
				if (_uiMode != value)
				{
					_uiMode = value;
					VRMod.StaticLogger.LogInfo((object)string.Format("[VR input] {0} hand UI-pointer mode = {1} (paused={2}).", ((int)xrNode == 4) ? "Left" : "Right", _uiMode, PauseManager.isPaused));
					if (_uiMode)
					{
						((Component)ray).gameObject.layer = LayerIndex.ui.intVal;
						((Renderer)ray).sortingOrder = 999;
						((Component)currentHand).gameObject.SetLayerRecursive(LayerIndex.noDraw.intVal);
						((Component)uiHand).gameObject.SetActive(false);
						((Component)ray).gameObject.SetActive(false);
					}
					else
					{
						((Component)ray).gameObject.layer = 0;
						((Renderer)ray).sortingOrder = 0;
						((Component)currentHand).gameObject.SetLayerRecursive(0);
						((Component)uiHand).gameObject.SetActive(false);
						UpdateRayColor();
					}
				}
			}
		}

		internal static Quaternion PoseCorrection => Quaternion.Euler(ModConfig.ControllerAngleOffset.Value, 0f, 0f);

		private void Awake()
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			SetCurrentHand(pointerHand);
			uiHand = Object.Instantiate<GameObject>(((Component)pointerHand).gameObject).GetComponent<Hand>();
			((Component)uiHand).gameObject.SetLayerRecursive(LayerIndex.ui.intVal);
			uiHand.useRay = false;
			((Component)uiHand).gameObject.SetActive(false);
			((Renderer)ray).material.color = ModConfig.RayColor;
			lastPosition = Vector3.zero;
			lastRotation = Quaternion.identity;
		}

		private void OnEnable()
		{
			if (uiMode && Object.op_Implicit((Object)(object)uiHand) && !((Behaviour)uiHand).isActiveAndEnabled)
			{
				((Component)uiHand).gameObject.SetActive(true);
			}
		}

		private void OnDisable()
		{
			if (Object.op_Implicit((Object)(object)uiHand) && ((Behaviour)uiHand).isActiveAndEnabled)
			{
				((Component)uiHand).gameObject.SetActive(false);
			}
		}

		private void Start()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			if (Object.op_Implicit((Object)(object)uiHand))
			{
				((Object)((Component)uiHand).gameObject).name = string.Format("UI Hand ({0})", ((int)xrNode == 4) ? "Left" : "Right");
			}
		}

		private void OnDestroy()
		{
			if (Object.op_Implicit((Object)(object)uiHand))
			{
				Object.Destroy((Object)(object)((Component)uiHand).gameObject);
			}
		}

		private void Update()
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			uiMode = Utils.isUsingUI;
			if ((Object)(object)((Component)this).transform.parent != (Object)(object)((Component)Camera.main).transform.parent)
			{
				((Component)this).transform.SetParent(((Component)Camera.main).transform.parent, false);
			}
			((Component)uiHand).transform.position = ((Component)this).transform.position;
			((Component)uiHand).transform.rotation = ((Component)this).transform.rotation * PoseCorrection;
		}

		private void LateUpdate()
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)currentHand))
			{
				bool flag = rayActive;
				if (((Component)ray).gameObject.activeSelf != flag)
				{
					((Component)ray).gameObject.SetActive(flag);
				}
				if (((Component)ray).gameObject.activeSelf)
				{
					((Component)ray).transform.position = (uiMode ? ((Component)uiHand.currentMuzzle).transform : muzzle).position;
					ray.SetPosition(1, ((Component)ray).transform.InverseTransformPoint(GetRayHitPosition()));
				}
			}
		}

		public Transform GetMuzzleByIndex(uint index)
		{
			return ((Component)currentHand.muzzles[index]).transform;
		}

		internal void SetCurrentHand(string bodyName)
		{
			foreach (GameObject handPrefab in handPrefabs)
			{
				Hand component = handPrefab.GetComponent<Hand>();
				if (Object.op_Implicit((Object)(object)component) && component.bodyName == bodyName)
				{
					Hand component2 = Object.Instantiate<GameObject>(handPrefab, ((Component)this).transform).GetComponent<Hand>();
					SetCurrentHand(component2);
					return;
				}
			}
			if (ModConfig.RuntimeHands.Value)
			{
				Hand hand = RuntimeHands.TryBuildHand(this, bodyName);
				if (Object.op_Implicit((Object)(object)hand))
				{
					SetCurrentHand(hand);
					return;
				}
				RuntimeHands.ScheduleRetry(this, bodyName);
			}
			VRMod.StaticLogger.LogWarning((object)("Could not find hand with name '" + bodyName + "'. This character is likely not VR supported and some abilities might not work as intended. Using default pointer."));
		}

		internal void SetPrefabs(List<GameObject> prefabs)
		{
			if (prefabs != null)
			{
				handPrefabs = prefabs;
			}
		}

		private void SetCurrentHand(Hand hand)
		{
			//IL_0040: 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)
			if (Object.op_Implicit((Object)(object)currentHand))
			{
				Object.Destroy((Object)(object)((Component)currentHand).gameObject);
			}
			currentHand = hand;
			((Component)currentHand).gameObject.SetActive(true);
			((Component)currentHand).transform.localRotation = PoseCorrection * ((Component)currentHand).transform.localRotation;
			((Component)ray).gameObject.SetActive(rayActive);
		}

		private Vector3 GetRayHitPosition()
		{
			//IL_000d: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)currentHand))
			{
				return Vector3.zero;
			}
			Ray val = (uiMode ? uiRay : aimRay);
			LayerIndex val2;
			LayerMask mask;
			if (!uiMode)
			{
				val2 = LayerIndex.ragdoll;
				mask = ((LayerIndex)(ref val2)).mask;
			}
			else
			{
				val2 = LayerIndex.ui;
				mask = ((LayerIndex)(ref val2)).mask;
			}
			LayerMask val3 = mask;
			RaycastHit val4 = default(RaycastHit);
			if (Physics.Raycast(val, ref val4, 300f, LayerMask.op_Implicit(val3)))
			{
				return ((RaycastHit)(ref val4)).point;
			}
			return ((Ray)(ref val)).origin + ((Ray)(ref val)).direction * 300f;
		}

		internal void UpdateRayColor()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			((Renderer)ray).material.color = ModConfig.RayColor;
		}
	}
	internal class HandHUD : MonoBehaviour
	{
		[SerializeField]
		private bool faceCamera;

		[SerializeField]
		private bool hideWhenFacingAway;

		[SerializeField]
		private GameObject[] hudsToHideWhenVisible;

		private Canvas canvas;

		private CameraRigController cameraRig;

		private List<RectTransform> hudClusters = new List<RectTransform>();

		private Vector3 origScale;

		private float scaleLerp = 1f;

		private void Awake()
		{
			//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)
			canvas = ((Component)this).GetComponentInChildren<Canvas>();
			((Component)canvas).transform.SetParent((Transform)null);
			((Component)canvas).gameObject.layer = LayerIndex.ui.intVal;
			origScale = ((Component)this).transform.localScale;
		}

		private void OnDestroy()
		{
			if (Object.op_Implicit((Object)(object)canvas))
			{
				Object.Destroy((Object)(object)((Component)canvas).gameObject);
			}
		}

		internal void Init(CameraRigController rig)
		{
			cameraRig = rig;
			canvas.worldCamera = cameraRig.uiCam;
		}

		public void AddHUDCluster(RectTransform hudClusterTransform)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)hudClusterTransform))
			{
				hudClusters.Add(hudClusterTransform);
				((Transform)hudClusterTransform).SetParent(((Component)canvas).transform);
				((Transform)hudClusterTransform).localPosition = Vector3.zero;
				((Transform)hudClusterTransform).localRotation = Quaternion.identity;
				((Transform)hudClusterTransform).localScale = Vector3.one;
			}
		}

		private void LateUpdate()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)cameraRig) || !Object.op_Implicit((Object)(object)VRCameraWrapper.instance))
			{
				return;
			}
			Vector3 val = ((Component)VRCameraWrapper.instance).transform.InverseTransformPoint(((Component)this).transform.position);
			((Component)canvas).transform.position = val;
			((Component)canvas).transform.rotation = (faceCamera ? Quaternion.LookRotation(val - ((Component)cameraRig.uiCam).transform.position, ((Component)cameraRig.uiCam).transform.up) : Quaternion.LookRotation(((Component)VRCameraWrapper.instance).transform.InverseTransformVector(((Component)this).transform.forward), ((Component)VRCameraWrapper.instance).transform.InverseTransformVector(((Component)this).transform.up)));
			if (!hideWhenFacingAway || !Object.op_Implicit((Object)(object)cameraRig) || !Object.op_Implicit((Object)(object)canvas))
			{
				return;
			}
			bool flag = Vector3.Angle(((Component)this).transform.forward, ((Component)this).transform.position - ((Component)cameraRig.sceneCam).transform.position) <= 45f;
			if (scaleLerp == (flag ? 1f : 0f))
			{
				return;
			}
			scaleLerp = Mathf.Clamp(scaleLerp + (flag ? Time.unscaledDeltaTime : (0f - Time.unscaledDeltaTime)) * 6f, 0f, 1f);
			((Component)canvas).transform.localScale = Vector3.Lerp(Vector3.zero, origScale, scaleLerp);
			GameObject[] array = hudsToHideWhenVisible;
			foreach (GameObject val2 in array)
			{
				if (val2.activeSelf == flag)
				{
					val2.SetActive(!flag);
				}
			}
		}
	}
	internal class MotionControlledAbilities
	{
		private struct ScaledEffect
		{
			internal GameObject effectPrefab;

			internal float effectScale;

			internal ScaledEffect(GameObject prefab, float scale)
			{
				effectPrefab = prefab;
				effectScale = scale;
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__SprintBreakDirection;

			public static hook_CheckPinging <1>__PingFromHand;

			public static hook_ModifyAimRayIfApplicable <2>__CancelModifyIfLocal;

			public static hook_GetAimRay <3>__GetLeftAimRay;

			public static hook_GetAimRay <4>__EditAimray;

			public static hook_FireBullet <5>__ForceShotgunMuzzle;

			public static hook_GenerateBulletAttack <6>__ChangeShotgunMuzzle;

			public static hook_FireProjectile <7>__SetFMJMuzzle;

			public static hook_FireBullet <8>__CheckPistolBulletMuzzle;

			public static hook_FireBullet <9>__PlayBarrageShootAnimation;

			public static hook_PlayAnimation <10>__PlayFMJShootAnimation;

			public static hook_FireOrbArrow <11>__AnimatePrimaryBowShoot;

			public static hook_OnExit <12>__PreventBowPull;

			public static hook_OnEnter <13>__DeleteEffect;

			public static hook_FireOrbGlaive <14>__AnimateGlaiveThrow;

			public static hook_GetBlinkVector <15>__GetNonDominantVector;

			public static hook_OnEnter <16>__AnimateBarrageBowPull;

			public static hook_HandlePrimaryAttack <17>__AnimateBarrageBowShoot;

			public static hook_HandlePrimaryAttack <18>__AnimateSnipeBow;

			public static hook_OnExit <19>__HideArrowCluster;

			public static hook_OnEnter <20>__ChangeSlashDirection;

			public static hook_OnEnter <21>__PlayRevolverSpinAnimation;

			public static hook_FireBullet <22>__SetNailgunMuzzle;

			public static hook_OnEnter <23>__SetScrapMuzzle;

			public static hook_FireBullet <24>__SetRebarMuzzle;

			public static hook_OnEnter <25>__AnimateChargeSpear;

			public static hook_OnExit <26>__AnimateSpinDown;

			public static hook_OnExit <27>__AnimateSawSlowdown;

			public static hook_OnEnter <28>__ForceBuzzsawMuzzle;

			public static hook_OnEnter <29>__AnimateRetoolRetract;

			public static hook_FixedUpdate <30>__AnimateRetoolExtend;

			public static hook_OnEnter <31>__AnimateDualWieldRetract;

			public static hook_FixedUpdate <32>__AnimateDualWieldExtend;

			public static hook_OnExit <33>__AnimateDualWieldEnd;

			public static MotionControls.SetHandPairEventHandler <34>__SetInitialTool;

			public static hook_OnExit <35>__AnimateGrenadeThrow;

			public static hook_OnEnter <36>__AnimateDashExtend;

			public static Manipulator <37>__SetGrenadeMuzzle;

			public static hook_FireGrenade <38>__RemoveMuzzleFlash;

			public static hook_OnExit <39>__AnimateGrenadeRelease;

			public static hook_OnExit <40>__AnimateHarpoonRelease;

			public static hook_OnExit <41>__AnimateBlueprintRelease;

			public static hook_FireGauntlet <42>__SetFireboltMuzzle;

			public static hook_OnEnter <43>__ShrinkFireEffect;

			public static hook_FireGauntlet <44>__DestroyOffHandEffect;

			public static hook_OnExit <45>__StopCastAnimation;

			public static hook_OnEnter <46>__ShrinkNovaBomb;

			public static hook_OnEnter <47>__AnimateBombCast;

			public static hook_OnExit <48>__AnimateWallCast;

			public static hook_OnEnter <49>__ChangeWhirlwindDirection;

			public static hook_FixedUpdate <50>__ForceWhirlwindDirection;

			public static hook_OnEnter <51>__ChangeUppercutDirection;

			public static hook_OnEnter <52>__ForceDashDirection;

			public static hook_OnEnter <53>__ForceFocusedDashDirection;

			public static hook_FixedUpdate <54>__AnimateSyringeShoot;

			public static hook_OnExit <55>__EndSyringeShoot;

			public static hook_OnEnter <56>__AnimateSonicBoom;

			public static hook_OnEnter <57>__AnimateHookEnter;

			public static hook_OnExit <58>__AnimateHookExit;

			public static hook_OnEnter <59>__ShowLoaderRay;

			public static hook_OnExit <60>__HideLoaderRay;

			public static hook_GetOwnerAimRay <61>__GetGrappleArmRay;

			public static hook_OnEnter <62>__ChangeBiteDirection;

			public static hook_OnExit <63>__AnimateAcridRest;

			public static hook_OnEnter <64>__ShrinkChargeEffect;

			public static hook_OnEnter <65>__AnimateShotgunShoot;

			public static hook_OnEnter <66>__ChangeTazerMuzzleEnter;

			public static hook_Fire <67>__ChangeTazerMuzzleShoot;

			public static hook_OnEnter <68>__SetScopeFOV;

			public static hook_OnEnter <69>__RemoveOverlay;

			public static hook_OnEnter <70>__ChangeSniperMuzzle;

			public static hook_OnEnter <71>__ChangeBlinkDirection;

			public static Manipulator <72>__ChangeNeedleMuzzle;
		}

		private static bool preventBowPull = false;

		private static Vector3 abilityDirection = Vector3.zero;

		private static List<Type> nonDominantHandStateTypes = new List<Type>
		{
			typeof(FireFMJ),
			typeof(Bandit2FireShiv),
			typeof(AimStunDrone),
			typeof(FireMines),
			typeof(FireSpiderMine),
			typeof(FireBubbleShield),
			typeof(PrepWall),
			typeof(ThrowNovabomb),
			typeof(ThrowIcebomb),
			typeof(PrepAssaulter2),
			typeof(FocusedAssaultPrep),
			typeof(AimMortar2),
			typeof(AimMortarRain),
			typeof(FireSonicBoom),
			typeof(FirePlantSonicBoom),
			typeof(ThrowPylon),
			typeof(FireHook),
			typeof(FireYankHook),
			typeof(FireSpit),
			typeof(Bite),
			typeof(Leap),
			typeof(ChainableLeap),
			typeof(FireTazer),
			typeof(ThrowLunarSecondary),
			typeof(FireMineConcussive),
			typeof(FireMineBlinding),
			typeof(FireMegaBlasterBig),
			typeof(FireMegaBlasterSmall),
			typeof(FireCorruptDisks)
		};

		private static Dictionary<Type, bool> forceAimRaySideTypes = new Dictionary<Type, bool>
		{
			{
				typeof(PingerController),
				false
			},
			{
				typeof(InteractionDriver),
				false
			}
		};

		private static string[] multPrimarySkills = new string[5] { "Hand", "FireNailgun", "FireSpear", "FireGrenadeLauncher", "FireBuzzsaw" };

		private static FixedTimeStamp halfTime;

		private static bool isSwapping;

		internal static void Init()
		{
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Expected O, but got Unknown
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Expected O, but got Unknown
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Expected O, but got Unknown
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Expected O, but got Unknown
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Unknown result type (might be due to invalid IL or missing references)
			//IL_0379: Expected O, but got Unknown
			//IL_038e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Expected O, but got Unknown
			//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: Expected O, but got Unknown
			//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d9: Expected O, but got Unknown
			//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f9: Expected O, but got Unknown
			//IL_040e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0413: Unknown result type (might be due to invalid IL or missing references)
			//IL_0419: Expected O, but got Unknown
			//IL_042e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0433: Unknown result type (might be due to invalid IL or missing references)
			//IL_0439: Expected O, but got Unknown
			//IL_044e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0453: Unknown result type (might be due to invalid IL or missing references)
			//IL_0459: Expected O, but got Unknown
			//IL_046e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0473: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Expected O, but got Unknown
			//IL_048e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0493: Unknown result type (might be due to invalid IL or missing references)
			//IL_0499: Expected O, but got Unknown
			//IL_04ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b9: Expected O, but got Unknown
			//IL_04ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d9: Expected O, but got Unknown
			//IL_04ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f9: Expected O, but got Unknown
			//IL_050e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0513: Unknown result type (might be due to invalid IL or missing references)
			//IL_0519: Expected O, but got Unknown
			//IL_052e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0533: Unknown result type (might be due to invalid IL or missing references)
			//IL_0539: Expected O, but got Unknown
			//IL_054e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0553: Unknown result type (might be due to invalid IL or missing references)
			//IL_0559: Expected O, but got Unknown
			//IL_056e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0573: Unknown result type (might be due to invalid IL or missing references)
			//IL_0579: Expected O, but got Unknown
			//IL_058e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0593: Unknown result type (might be due to invalid IL or missing references)
			//IL_0599: Expected O, but got Unknown
			//IL_05ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b9: Expected O, but got Unknown
			//IL_05ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d9: Expected O, but got Unknown
			//IL_05ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f9: Expected O, but got Unknown
			//IL_060e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0613: Unknown result type (might be due to invalid IL or missing references)
			//IL_0619: Expected O, but got Unknown
			//IL_062e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0633: Unknown result type (might be due to invalid IL or missing references)
			//IL_0639: Expected O, but got Unknown
			//IL_064e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0653: Unknown result type (might be due to invalid IL or missing references)
			//IL_0659: Expected O, but got Unknown
			//IL_066e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0673: Unknown result type (might be due to invalid IL or missing references)
			//IL_0679: Expected O, but got Unknown
			//IL_068e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0693: Unknown result type (might be due to invalid IL or missing references)
			//IL_0699: Expected O, but got Unknown
			//IL_06ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b9: Expected O, but got Unknown
			//IL_06ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d9: Expected O, but got Unknown
			//IL_06ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f9: Expected O, but got Unknown
			//IL_070e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0713: Unknown result type (might be due to invalid IL or missing references)
			//IL_0719: Expected O, but got Unknown
			//IL_072e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0733: Unknown result type (might be due to invalid IL or missing references)
			//IL_0739: Expected O, but got Unknown
			//IL_077d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0782: Unknown result type (might be due to invalid IL or missing references)
			//IL_0788: Expected O, but got Unknown
			//IL_079d: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a8: Expected O, but got Unknown
			//IL_07bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c8: Expected O, but got Unknown
			//IL_07dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e8: Expected O, but got Unknown
			//IL_07fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0802: Unknown result type (might be due to invalid IL or missing references)
			//IL_0808: Expected O, but got Unknown
			//IL_081d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0822: Unknown result type (might be due to invalid IL or missing references)
			//IL_0828: Expected O, but got Unknown
			//IL_083d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0842: Unknown result type (might be due to invalid IL or missing references)
			//IL_0848: Expected O, but got Unknown
			//IL_085d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0862: Unknown result type (might be due to invalid IL or missing references)
			//IL_0868: Expected O, but got Unknown
			//IL_087d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0882: Unknown result type (might be due to invalid IL or missing references)
			//IL_0888: Expected O, but got Unknown
			//IL_089d: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a8: Expected O, but got Unknown
			//IL_08bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c8: Expected O, but got Unknown
			//IL_08dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e8: Expected O, but got Unknown
			//IL_08fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0902: Unknown result type (might be due to invalid IL or missing references)
			//IL_0908: Expected O, but got Unknown
			//IL_091d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0922: Unknown result type (might be due to invalid IL or missing references)
			//IL_0928: Expected O, but got Unknown
			//IL_093d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0942: Unknown result type (might be due to invalid IL or missing references)
			//IL_0948: Expected O, but got Unknown
			//IL_095d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0962: Unknown result type (might be due to invalid IL or missing references)
			//IL_0968: Expected O, but got Unknown
			//IL_097d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0982: Unknown result type (might be due to invalid IL or missing references)
			//IL_0988: Expected O, but got Unknown
			//IL_099d: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a8: Expected O, but got Unknown
			//IL_09bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_09c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_09c8: Expected O, but got Unknown
			//IL_09dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_09e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_09e8: Expected O, but got Unknown
			//IL_09fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a02: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a08: Expected O, but got Unknown
			//IL_0a1d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a22: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a28: Expected O, but got Unknown
			//IL_0a3d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a42: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a48: Expected O, but got Unknown
			//IL_0a5d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a62: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a68: Expected O, but got Unknown
			//IL_0a7d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a82: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a88: Expected O, but got Unknown
			//IL_0a9d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa8: Expected O, but got Unknown
			//IL_0abd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ac2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ac8: Expected O, but got Unknown
			//IL_0add: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ae2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ae8: Expected O, but got Unknown
			//IL_0afd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b02: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b08: Expected O, but got Unknown
			//IL_0b1d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b22: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b28: Expected O, but got Unknown
			//IL_0b3d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b42: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b48: Expected O, but got Unknown
			//IL_0b5d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b62: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b68: Expected O, but got Unknown
			//IL_0b7d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b82: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b88: Expected O, but got Unknown
			//IL_0b9d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ba2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ba8: Expected O, but got Unknown
			//IL_0bbd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bc2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bc8: Expected O, but got Unknown
			//IL_0bdd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0be2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0be8: Expected O, but got Unknown
			//IL_0bfd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c02: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c08: Expected O, but got Unknown
			//IL_0c1d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c22: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c28: Expected O, but got Unknown
			foreach (ScaledEffect item in new List<ScaledEffect>
			{
				new ScaledEffect(LegacyResourcesAPI.Load<GameObject>("prefabs/effects/muzzleflashes/Muzzleflash1"), 0.4f),
				new ScaledEffect(LegacyResourcesAPI.Load<GameObject>("prefabs/effects/muzzleflashes/MuzzleflashFMJ"), 0.4f),
				new ScaledEffect(LegacyResourcesAPI.Load<GameObject>("prefabs/effects/muzzleflashes/MuzzleflashBarrage"), 0.4f),
				new ScaledEffect(LegacyResourcesAPI.Load<GameObject>("prefabs/effects/muzzleflashes/MuzzleflashHuntress"), 0.5f),
				new ScaledEffect(LegacyResourcesAPI.Load<GameObject>("prefabs/effects/muzzleflashes/MuzzleflashEngiGrenade"), 0.5f),
				new ScaledEffect(LegacyResourcesAPI.Load<GameObject>("prefabs/effects/muzzleflashes/MuzzleflashMageFire"), 0.5f),
				new ScaledEffect(LegacyResourcesAPI.Load<GameObject>("prefabs/effects/muzzleflashes/MuzzleflashMageLightning"), 0.5f),
				new ScaledEffect(((Component)LegacyResourcesAPI.Load<GameObject>("prefabs/effects/muzzleflashes/MuzzleflashMageLightningLarge").transform.Find("Particles")).gameObject, 0.5f),
				new ScaledEffect(((Component)LegacyResourcesAPI.Load<GameObject>("prefabs/effects/muzzleflashes/MuzzleflashMageIceLarge").transform.Find("Particles")).gameObject, 0.5f),
				new ScaledEffect(((Component)LegacyResourcesAPI.Load<GameObject>("prefabs/effects/muzzleflashes/MuzzleflashMageLightningLargeWithTrail").transform.Find("Particles")).gameObject, 0.5f),
				new ScaledEffect(Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/VoidSurvivor/VoidSurvivorBeamMuzzleflash.prefab").WaitForCompletion(), 0.4f),
				new ScaledEffect(Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/VoidSurvivor/VoidSurvivorChargeMegaBlaster.prefab").WaitForCompletion(), 0.6f),
				new ScaledEffect(Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/VoidSurvivor/VoidSurvivorReadyMegaBlaster.prefab").WaitForCompletion(), 0.6f),
				new ScaledEffect(Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/VoidSurvivor/VoidSurvivorChargeCrushCorruption.prefab").WaitForCompletion(), 0.6f),
				new ScaledEffect(Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/VoidSurvivor/VoidSurvivorChargeCrushHealth.prefab").WaitForCompletion(), 0.6f)
			})
			{
				foreach (Transform item2 in item.effectPrefab.transform)
				{
					Transform val = item2;
					if (!((Object)val).name.ToLower().Contains("light"))
					{
						val.localScale *= item.effectScale;
					}
				}
			}
			((Component)LegacyResourcesAPI.Load<GameObject>("prefabs/effects/muzzleflashes/Bandit2SmokeBomb").transform.Find("Core/Dust, CenterTube")).gameObject.SetActive(false);
			Transform obj = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/VoidSurvivor/VoidSurvivorBeamCorrupt.prefab").WaitForCompletion().transform.Find("Offset");
			obj.localPosition = new Vector3(0f, 0f, 0.1f);
			obj.localScale = new Vector3(0.6f, 0.6f, 1f);
			object obj2 = <>O.<0>__SprintBreakDirection;
			if (obj2 == null)
			{
				Manipulator val2 = SprintBreakDirection;
				<>O.<0>__SprintBreakDirection = val2;
				obj2 = (object)val2;
			}
			PlayerCharacterMasterController.PollButtonInput += (Manipulator)obj2;
			object obj3 = <>O.<1>__PingFromHand;
			if (obj3 == null)
			{
				hook_CheckPinging val3 = PingFromHand;
				<>O.<1>__PingFromHand = val3;
				obj3 = (object)val3;
			}
			PlayerCharacterMasterController.CheckPinging += (hook_CheckPinging)obj3;
			object obj4 = <>O.<2>__CancelModifyIfLocal;
			if (obj4 == null)
			{
				hook_ModifyAimRayIfApplicable val4 = CancelModifyIfLocal;
				<>O.<2>__CancelModifyIfLocal = val4;
				obj4 = (object)val4;
			}
			CameraRigController.ModifyAimRayIfApplicable += (hook_ModifyAimRayIfApplicable)obj4;
			object obj5 = <>O.<3>__GetLeftAimRay;
			if (obj5 == null)
			{
				hook_GetAimRay val5 = GetLeftAimRay;
				<>O.<3>__GetLeftAimRay = val5;
				obj5 = (object)val5;
			}
			EquipmentSlot.GetAimRay += (hook_GetAimRay)obj5;
			object obj6 = <>O.<4>__EditAimray;
			if (obj6 == null)
			{
				hook_GetAimRay val6 = EditAimray;
				<>O.<4>__EditAimray = val6;
				obj6 = (object)val6;
			}
			BaseState.GetAimRay += (hook_GetAimRay)obj6;
			object obj7 = <>O.<5>__ForceShotgunMuzzle;
			if (obj7 == null)
			{
				hook_FireBullet val7 = ForceShotgunMuzzle;
				<>O.<5>__ForceShotgunMuzzle = val7;
				obj7 = (object)val7;
			}
			GenericBulletBaseState.FireBullet += (hook_FireBullet)obj7;
			object obj8 = <>O.<6>__ChangeShotgunMuzzle;
			if (obj8 == null)
			{
				hook_GenerateBulletAttack val8 = ChangeShotgunMuzzle;
				<>O.<6>__ChangeShotgunMuzzle = val8;
				obj8 = (object)val8;
			}
			GenericBulletBaseState.GenerateBulletAttack += (hook_GenerateBulletAttack)obj8;
			object obj9 = <>O.<7>__SetFMJMuzzle;
			if (obj9 == null)
			{
				hook_FireProjectile val9 = SetFMJMuzzle;
				<>O.<7>__SetFMJMuzzle = val9;
				obj9 = (object)val9;
			}
			GenericProjectileBaseState.FireProjectile += (hook_FireProjectile)obj9;
			object obj10 = <>O.<8>__CheckPistolBulletMuzzle;
			if (obj10 == null)
			{
				hook_FireBullet val10 = CheckPistolBulletMuzzle;
				<>O.<8>__CheckPistolBulletMuzzle = val10;
				obj10 = (object)val10;
			}
			FirePistol2.FireBullet += (hook_FireBullet)obj10;
			object obj11 = <>O.<9>__PlayBarrageShootAnimation;
			if (obj11 == null)
			{
				hook_FireBullet val11 = PlayBarrageShootAnimation;
				<>O.<9>__PlayBarrageShootAnimation = val11;
				obj11 = (object)val11;
			}
			FireBarrage.FireBullet += (hook_FireBullet)obj11;
			object obj12 = <>O.<10>__PlayFMJShootAnimation;
			if (obj12 == null)
			{
				hook_PlayAnimation val12 = PlayFMJShootAnimation;
				<>O.<10>__PlayFMJShootAnimation = val12;
				obj12 = (object)val12;
			}
			FireFMJ.PlayAnimation += (hook_PlayAnimation)obj12;
			object obj13 = <>O.<11>__AnimatePrimaryBowShoot;
			if (obj13 == null)
			{
				hook_FireOrbArrow val13 = AnimatePrimaryBowShoot;
				<>O.<11>__AnimatePrimaryBowShoot = val13;
				obj13 = (object)val13;
			}
			FireSeekingArrow.FireOrbArrow += (hook_FireOrbArrow)obj13;
			object obj14 = <>O.<12>__PreventBowPull;
			if (obj14 == null)
			{
				hook_OnExit val14 = PreventBowPull;
				<>O.<12>__PreventBowPull = val14;
				obj14 = (object)val14;
			}
			FireSeekingArrow.OnExit += (hook_OnExit)obj14;
			object obj15 = <>O.<13>__DeleteEffect;
			if (obj15 == null)
			{
				hook_OnEnter val15 = DeleteEffect;
				<>O.<13>__DeleteEffect = val15;
				obj15 = (object)val15;
			}
			ThrowGlaive.OnEnter += (hook_OnEnter)obj15;
			object obj16 = <>O.<14>__AnimateGlaiveThrow;
			if (obj16 == null)
			{
				hook_FireOrbGlaive val16 = AnimateGlaiveThrow;
				<>O.<14>__AnimateGlaiveThrow = val16;
				obj16 = (object)val16;
			}
			ThrowGlaive.FireOrbGlaive += (hook_FireOrbGlaive)obj16;
			object obj17 = <>O.<15>__GetNonDominantVector;
			if (obj17 == null)
			{
				hook_GetBlinkVector val17 = GetNonDominantVector;
				<>O.<15>__GetNonDominantVector = val17;
				obj17 = (object)val17;
			}
			BlinkState.GetBlinkVector += (hook_GetBlinkVector)obj17;
			object obj18 = <>O.<16>__AnimateBarrageBowPull;
			if (obj18 == null)
			{
				hook_OnEnter val18 = AnimateBarrageBowPull;
				<>O.<16>__AnimateBarrageBowPull = val18;
				obj18 = (object)val18;
			}
			BaseArrowBarrage.OnEnter += (hook_OnEnter)obj18;
			object obj19 = <>O.<17>__AnimateBarrageBowShoot;
			if (obj19 == null)
			{
				hook_HandlePrimaryAttack val19 = AnimateBarrageBowShoot;
				<>O.<17>__AnimateBarrageBowShoot = val19;
				obj19 = (object)val19;
			}
			BaseArrowBarrage.HandlePrimaryAttack += (hook_HandlePrimaryAttack)obj19;
			object obj20 = <>O.<18>__AnimateSnipeBow;
			if (obj20 == null)
			{
				hook_HandlePrimaryAttack val20 = AnimateSnipeBow;
				<>O.<18>__AnimateSnipeBow = val20;
				obj20 = (object)val20;
			}
			AimArrowSnipe.HandlePrimaryAttack += (hook_HandlePrimaryAttack)obj20;
			object obj21 = <>O.<19>__HideArrowCluster;
			if (obj21 == null)
			{
				hook_OnExit val21 = HideArrowCluster;
				<>O.<19>__HideArrowCluster = val21;
				obj21 = (object)val21;
			}
			BaseArrowBarrage.OnExit += (hook_OnExit)obj21;
			object obj22 = <>O.<20>__ChangeSlashDirection;
			if (obj22 == null)
			{
				hook_OnEnter val22 = ChangeSlashDirection;
				<>O.<20>__ChangeSlashDirection = val22;
				obj22 = (object)val22;
			}
			SlashBlade.OnEnter += (hook_OnEnter)obj22;
			object obj23 = <>O.<21>__PlayRevolverSpinAnimation;
			if (obj23 == null)
			{
				hook_OnEnter val23 = PlayRevolverSpinAnimation;
				<>O.<21>__PlayRevolverSpinAnimation = val23;
				obj23 = (object)val23;
			}
			BasePrepSidearmRevolverState.OnEnter += (hook_OnEnter)obj23;
			object obj24 = <>O.<22>__SetNailgunMuzzle;
			if (obj24 == null)
			{
				hook_FireBullet val24 = SetNailgunMuzzle;
				<>O.<22>__SetNailgunMuzzle = val24;
				obj24 = (object)val24;
			}
			BaseNailgunState.FireBullet += (hook_FireBullet)obj24;
			object obj25 = <>O.<23>__SetScrapMuzzle;
			if (obj25 == null)
			{
				hook_OnEnter val25 = SetScrapMuzzle;
				<>O.<23>__SetScrapMuzzle = val25;
				obj25 = (object)val25;
			}
			FireGrenadeLauncher.OnEnter += (hook_OnEnter)obj25;
			object obj26 = <>O.<24>__SetRebarMuzzle;
			if (obj26 == null)
			{
				hook_FireBullet val26 = SetRebarMuzzle;
				<>O.<24>__SetRebarMuzzle = val26;
				obj26 = (object)val26;
			}
			FireSpear.FireBullet += (hook_FireBullet)obj26;
			object obj27 = <>O.<25>__AnimateChargeSpear;
			if (obj27 == null)
			{
				hook_OnEnter val27 = AnimateChargeSpear;
				<>O.<25>__AnimateChargeSpear = val27;
				obj27 = (object)val27;
			}
			CooldownSpear.OnEnter += (hook_OnEnter)obj27;
			object obj28 = <>O.<26>__AnimateSpinDown;
			if (obj28 == null)
			{
				hook_OnExit val28 = AnimateSpinDown;
				<>O.<26>__AnimateSpinDown = val28;
				obj28 = (object)val28;
			}
			FireNailgun.OnExit += (hook_OnExit)obj28;
			object obj29 = <>O.<27>__AnimateSawSlowdown;
			if (obj29 == null)
			{
				hook_OnExit val29 = AnimateSawSlowdown;
				<>O.<27>__AnimateSawSlowdown = val29;
				obj29 = (object)val29;
			}
			FireBuzzsaw.OnExit += (hook_OnExit)obj29;
			object obj30 = <>O.<28>__ForceBuzzsawMuzzle;
			if (obj30 == null)
			{
				hook_OnEnter val30 = ForceBuzzsawMuzzle;
				<>O.<28>__ForceBuzzsawMuzzle = val30;
				obj30 = (object)val30;
			}
			BaseToolbotPrimarySkillState.OnEnter += (hook_OnEnter)obj30;
			object obj31 = <>O.<29>__AnimateRetoolRetract;
			if (obj31 == null)
			{
				hook_OnEnter val31 = AnimateRetoolRetract;
				<>O.<29>__AnimateRetoolRetract = val31;
				obj31 = (object)val31;
			}
			ToolbotStanceSwap.OnEnter += (hook_OnEnter)obj31;
			object obj32 = <>O.<30>__AnimateRetoolExtend;
			if (obj32 == null)
			{
				hook_FixedUpdate val32 = AnimateRetoolExtend;
				<>O.<30>__AnimateRetoolExtend = val32;
				obj32 = (object)val32;
			}
			ToolbotStanceSwap.FixedUpdate += (hook_FixedUpdate)obj32;
			object obj33 = <>O.<31>__AnimateDualWieldRetract;
			if (obj33 == null)
			{
				hook_OnEnter val33 = AnimateDualWieldRetract;
				<>O.<31>__AnimateDualWieldRetract = val33;
				obj33 = (object)val33;
			}
			ToolbotDualWieldStart.OnEnter += (hook_OnEnter)obj33;
			object obj34 = <>O.<32>__AnimateDualWieldExtend;
			if (obj34 == null)
			{
				hook_FixedUpdate val34 = AnimateDualWieldExtend;
				<>O.<32>__AnimateDualWieldExtend = val34;
				obj34 = (object)val34;
			}
			ToolbotDualWieldStart.FixedUpdate += (hook_FixedUpdate)obj34;
			object obj35 = <>O.<33>__AnimateDualWieldEnd;
			if (obj35 == null)
			{
				hook_OnExit val35 = AnimateDualWieldEnd;
				<>O.<33>__AnimateDualWieldEnd = val35;
				obj35 = (object)val35;
			}
			ToolbotDualWield.OnExit += (hook_OnExit)obj35;
			MotionControls.onHandPairSet = (MotionControls.SetHandPairEventHandler)Delegate.Combine(MotionControls.onHandPairSet, new MotionControls.SetHandPairEventHandler(SetInitialTool));
			object obj36 = <>O.<35>__AnimateGrenadeThrow;
			if (obj36 == null)
			{
				hook_OnExit val36 = AnimateGrenadeThrow;
				<>O.<35>__AnimateGrenadeThrow = val36;
				obj36 = (object)val36;
			}
			AimStunDrone.OnExit += (hook_OnExit)obj36;
			object obj37 = <>O.<36>__AnimateDashExtend;
			if (obj37 == null)
			{
				hook_OnEnter val37 = AnimateDashExtend;
				<>O.<36>__AnimateDashExtend = val37;
				obj37 = (object)val37;
			}
			ToolbotDash.OnEnter += (hook_OnEnter)obj37;
			object obj38 = <>O.<37>__SetGrenadeMuzzle;
			if (obj38 == null)
			{
				Manipulator val38 = SetGrenadeMuzzle;
				<>O.<37>__SetGrenadeMuzzle = val38;
				obj38 = (object)val38;
			}
			RecoverAimStunDrone.OnEnter += (Manipulator)obj38;
			object obj39 = <>O.<38>__RemoveMuzzleFlash;
			if (obj39 == null)
			{
				hook_FireGrenade val39 = RemoveMuzzleFlash;
				<>O.<38>__RemoveMuzzleFlash = val39;
				obj39 = (object)val39;
			}
			FireGrenades.FireGrenade += (hook_FireGrenade)obj39;
			object obj40 = <>O.<39>__AnimateGrenadeRelease;
			if (obj40 == null)
			{
				hook_OnExit val40 = AnimateGrenadeRelease;
				<>O.<39>__AnimateGrenadeRelease = val40;
				obj40 = (object)val40;
			}
			ChargeGrenades.OnExit += (hook_OnExit)obj40;
			object obj41 = <>O.<40>__AnimateHarpoonRelease;
			if (obj41 == null)
			{
				hook_OnExit val41 = AnimateHarpoonRelease;
				<>O.<40>__AnimateHarpoonRelease = val41;
				obj41 = (object)val41;
			}
			Paint.OnExit += (hook_OnExit)obj41;
			object obj42 = <>O.<41>__AnimateBlueprintRelease;
			if (obj42 == null)
			{
				hook_OnExit val42 = AnimateBlueprintRelease;
				<>O.<41>__AnimateBlueprintRelease = val42;
				obj42 = (object)val42;
			}
			PlaceTurret.OnExit += (hook_OnExit)obj42;
			object obj43 = <>O.<42>__SetFireboltMuzzle;
			if (obj43 == null)
			{
				hook_FireGauntlet val43 = SetFireboltMuzzle;
				<>O.<42>__SetFireboltMuzzle = val43;
				obj43 = (object)val43;
			}
			FireFireBolt.FireGauntlet += (hook_FireGauntlet)obj43;
			object obj44 = <>O.<43>__ShrinkFireEffect;
			if (obj44 == null)
			{
				hook_OnEnter val44 = ShrinkFireEffect;
				<>O.<43>__ShrinkFireEffect = val44;
				obj44 = (object)val44;
			}
			Flamethrower.OnEnter += (hook_OnEnter)obj44;
			object obj45 = <>O.<44>__DestroyOffHandEffect;
			if (obj45 == null)
			{
				hook_FireGauntlet val45 = DestroyOffHandEffect;
				<>O.<44>__DestroyOffHandEffect = val45;
				obj45 = (object)val45;
			}
			Flamethrower.FireGauntlet += (hook_FireGauntlet)obj45;
			object obj46 = <>O.<45>__StopCastAnimation;
			if (obj46 == null)
			{
				hook_OnExit val46 = StopCastAnimation;
				<>O.<45>__StopCastAnimation = val46;
				obj46 = (object)val46;
			}
			Flamethrower.OnExit += (hook_OnExit)obj46;
			object obj47 = <>O.<46>__ShrinkNovaBomb;
			if (obj47 == null)
			{
				hook_OnEnter val47 = ShrinkNovaBomb;
				<>O.<46>__ShrinkNovaBomb = val47;
				obj47 = (object)val47;
			}
			BaseChargeBombState.OnEnter += (hook_OnEnter)obj47;
			object obj48 = <>O.<47>__AnimateBombCast;
			if (obj48 == null)
			{
				hook_OnEnter val48 = AnimateBombCast;
				<>O.<47>__AnimateBombCast = val48;
				obj48 = (object)val48;
			}
			BaseThrowBombState.OnEnter += (hook_OnEnter)obj48;
			object obj49 = <>O.<48>__AnimateWallCast;
			if (obj49 == null)
			{
				hook_OnExit val49 = AnimateWallCast;
				<>O.<48>__AnimateWallCast = val49;
				obj49 = (object)val49;
			}
			PrepWall.OnExit += (hook_OnExit)obj49;
			object obj50 = <>O.<49>__ChangeWhirlwindDirection;
			if (obj50 == null)
			{
				hook_OnEnter val50 = ChangeWhirlwindDirection;
				<>O.<49>__ChangeWhirlwindDirection = val50;
				obj50 = (object)val50;
			}
			WhirlwindBase.OnEnter += (hook_OnEnter)obj50;
			object obj51 = <>O.<50>__ForceWhirlwindDirection;
			if (obj51 == null)
			{
				hook_FixedUpdate val51 = ForceWhirlwindDirection;
				<>O.<50>__ForceWhirlwindDirection = val51;
				obj51 = (object)val51;
			}
			WhirlwindBase.FixedUpdate += (hook_FixedUpdate)obj51;
			object obj52 = <>O.<51>__ChangeUppercutDirection;
			if (obj52 == null)
			{
				hook_OnEnter val52 = ChangeUppercutDirection;
				<>O.<51>__ChangeUppercutDirection = val52;
				obj52 = (object)val52;
			}
			Uppercut.OnEnter += (hook_OnEnter)obj52;
			object obj53 = <>O.<52>__ForceDashDirection;
			if (obj53 == null)
			{
				hook_OnEnter val53 = ForceDashDirection;
				<>O.<52>__ForceDashDirection = val53;
				obj53 = (object)val53;
			}
			Assaulter2.OnEnter += (hook_OnEnter)obj53;
			object obj54 = <>O.<53>__ForceFocusedDashDirection;
			if (obj54 == null)
			{
				hook_OnEnter val54 = ForceFocusedDashDirection;
				<>O.<53>__ForceFocusedDashDirection = val54;
				obj54 = (object)val54;
			}
			FocusedAssaultDash.OnEnter += (hook_OnEnter)obj54;
			object obj55 = <>O.<54>__AnimateSyringeShoot;
			if (obj55 == null)
			{
				hook_FixedUpdate val55 = AnimateSyringeShoot;
				<>O.<54>__AnimateSyringeShoot = val55;
				obj55 = (object)val55;
			}
			FireSyringe.FixedUpdate += (hook_FixedUpdate)obj55;
			object obj56 = <>O.<55>__EndSyringeShoot;
			if (obj56 == null)
			{
				hook_OnExit val56 = EndSyringeShoot;
				<>O.<55>__EndSyringeShoot = val56;
				obj56 = (object)val56;
			}
			FireSyringe.OnExit += (hook_OnExit)obj56;
			object obj57 = <>O.<56>__AnimateSonicBoom;
			if (obj57 == null)
			{
				hook_OnEnter val57 = AnimateSonicBoom;
				<>O.<56>__AnimateSonicBoom = val57;
				obj57 = (object)val57;
			}
			FireSonicBoom.OnEnter += (hook_OnEnter)obj57;
			object obj58 = <>O.<57>__AnimateHookEnter;
			if (obj58 == null)
			{
				hook_OnEnter val58 = AnimateHookEnter;
				<>O.<57>__AnimateHookEnter = val58;
				obj58 = (object)val58;
			}
			FireHook.OnEnter += (hook_OnEnter)obj58;
			object obj59 = <>O.<58>__AnimateHookExit;
			if (obj59 == null)
			{
				hook_OnExit val59 = AnimateHookExit;
				<>O.<58>__AnimateHookExit = val59;
				obj59 = (object)val59;
			}
			FireHook.OnExit += (hook_OnExit)obj59;
			object obj60 = <>O.<59>__ShowLoaderRay;
			if (obj60 == null)
			{
				hook_OnEnter val60 = ShowLoaderRay;
				<>O.<59>__ShowLoaderRay = val60;
				obj60 = (object)val60;
			}
			BaseChargeFist.OnEnter += (hook_OnEnter)obj60;
			object obj61 = <>O.<60>__HideLoaderRay;
			if (obj61 == null)
			{
				hook_OnExit val61 = HideLoaderRay;
				<>O.<60>__HideLoaderRay = val61;
				obj61 = (object)val61;
			}
			BaseChargeFist.OnExit += (hook_OnExit)obj61;
			object obj62 = <>O.<61>__GetGrappleArmRay;
			if (obj62 == null)
			{
				hook_GetOwnerAimRay val62 = GetGrappleArmRay;
				<>O.<61>__GetGrappleArmRay = val62;
				obj62 = (object)val62;
			}
			BaseState.GetOwnerAimRay += (hook_GetOwnerAimRay)obj62;
			object obj63 = <>O.<62>__ChangeBiteDirection;
			if (obj63 == null)
			{
				hook_OnEnter val63 = ChangeBiteDirection;
				<>O.<62>__ChangeBiteDirection = val63;
				obj63 = (object)val63;
			}
			Bite.OnEnter += (hook_OnEnter)obj63;
			object obj64 = <>O.<63>__AnimateAcridRest;
			if (obj64 == null)
			{
				hook_OnExit val64 = AnimateAcridRest;
				<>O.<63>__AnimateAcridRest = val64;
				obj64 = (object)val64;
			}
			BaseLeap.OnExit += (hook_OnExit)obj64;
			object obj65 = <>O.<64>__ShrinkChargeEffect;
			if (obj65 == null)
			{
				hook_OnEnter val65 = ShrinkChargeEffect;
				<>O.<64>__ShrinkChargeEffect = val65;
				obj65 = (object)val65;
			}
			ChargeCaptainShotgun.OnEnter += (hook_OnEnter)obj65;
			object obj66 = <>O.<65>__AnimateShotgunShoot;
			if (obj66 == null)
			{
				hook_OnEnter val66 = AnimateShotgunShoot;
				<>O.<65>__AnimateShotgunShoot = val66;
				obj66 = (object)val66;
			}
			FireCaptainShotgun.OnEnter += (hook_OnEnter)obj66;
			object obj67 = <>O.<66>__ChangeTazerMuzzleEnter;
			if (obj67 == null)
			{
				hook_OnEnter val67 = ChangeTazerMuzzleEnter;
				<>O.<66>__ChangeTazerMuzzleEnter = val67;
				obj67 = (object)val67;
			}
			FireTazer.OnEnter += (hook_OnEnter)obj67;
			object obj68 = <>O.<67>__ChangeTazerMuzzleShoot;
			if (obj68 == null)
			{
				hook_Fire val68 = ChangeTazerMuzzleShoot;
				<>O.<67>__ChangeTazerMuzzleShoot = val68;
				obj68 = (object)val68;
			}
			FireTazer.Fire += (hook_Fire)obj68;
			object obj69 = <>O.<68>__SetScopeFOV;
			if (obj69 == null)
			{
				hook_OnEnter val69 = SetScopeFOV;
				<>O.<68>__SetScopeFOV = val69;
				obj69 = (object)val69;
			}
			BaseWindUp.OnEnter += (hook_OnEnter)obj69;
			object obj70 = <>O.<69>__RemoveOverlay;
			if (obj70 == null)
			{
				hook_OnEnter val70 = RemoveOverlay;
				<>O.<69>__RemoveOverlay = val70;
				obj70 = (object)val70;
			}
			BaseScopeState.OnEnter += (hook_OnEnter)obj70;
			object obj71 = <>O.<70>__ChangeSniperMuzzle;
			if (obj71 == null)
			{
				hook_OnEnter val71 = ChangeSniperMuzzle;
				<>O.<70>__ChangeSniperMuzzle = val71;
				obj71 = (object)val71;
			}
			BaseFireSnipe.OnEnter += (hook_OnEnter)obj71;
			object obj72 = <>O.<71>__ChangeBlinkDirection;
			if (obj72 == null)
			{
				hook_OnEnter val72 = ChangeBlinkDirection;
				<>O.<71>__ChangeBlinkDirection = val72;
				obj72 = (object)val72;
			}
			VoidBlinkBase.OnEnter += (hook_OnEnter)obj72;
			object obj73 = <>O.<72>__ChangeNeedleMuzzle;
			if (obj73 == null)
			{
				Manipulator val73 = ChangeNeedleMuzzle;
				<>O.<72>__ChangeNeedleMuzzle = val73;
				obj73 = (object)val73;
			}
			FireLunarNeedle.OnEnter += (Manipulator)obj73;
		}

		private static void ChangeSniperMuzzle(orig_OnEnter orig, BaseFireSnipe self)
		{
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				((GenericBulletBaseState)self).muzzleName = "MuzzleSniper";
			}
			orig.Invoke(self);
		}

		private static void RemoveOverlay(orig_OnEnter orig, BaseScopeState self)
		{
			Transform val = self.scopeOverlayPrefab.transform.Find("ScopeOverlay");
			if (Object.op_Implicit((Object)(object)val))
			{
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				self.overlayController.onInstanceAdded += delegate(OverlayController controller, GameObject instance)
				{
					((Component)MotionControls.GetHandByDominance(dominant: true).currentHand).GetComponent<SniperScopeController>().SetOverlay(instance);
				};
			}
		}

		private static void SetScopeFOV(orig_OnEnter orig, BaseWindUp self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				((Component)MotionControls.GetHandByDominance(dominant: true).currentHand).GetComponent<SniperScopeController>().SetFOV(((BaseScopeState)self).cameraParams.data.fov.value / ModConfig.RailgunnerZoomMultiplier.Value);
				MotionControls.GetHandByDominance(dominant: true).animator.SetBool("DisableRayOnScope", ModConfig.RailgunnerDisableScopeRay.Value);
			}
		}

		private static void ChangeBlinkDirection(orig_OnEnter orig, VoidBlinkBase self)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				Vector3 forward = MotionControls.GetHandByDominance(dominant: false).muzzle.forward;
				forward.y = 0f;
				((Vector3)(ref forward)).Normalize();
				self.forwardVector = forward;
			}
		}

		private static Ray GetGrappleArmRay(orig_GetOwnerAimRay orig, BaseState self)
		{
			//IL_004e: 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)
			BaseState val = (BaseState)(object)((self is BaseState) ? self : null);
			CharacterBody val2 = ((val != null) ? val.owner.characterBody : null);
			if (Object.op_Implicit((Object)(object)val2) && val2.IsLocalBody() && ((Object)((Component)val2).gameObject).name.Contains("LoaderBody"))
			{
				return MotionControls.GetHandByDominance(dominant: false).aimRay;
			}
			return orig.Invoke((BaseState)(object)val);
		}

		private static void ShrinkNovaBomb(orig_OnEnter orig, BaseChargeBombState self)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody() && self is ChargeNovabomb && Object.op_Implicit((Object)(object)self.chargeEffectInstance))
			{
				ObjectScaleCurve component = self.chargeEffectInstance.GetComponent<ObjectScaleCurve>();
				if (Object.op_Implicit((Object)(object)component))
				{
					Keyframe val = component.overallCurve.keys[1];
					((Keyframe)(ref val)).value = 0.5f;
					component.overallCurve.MoveKey(1, val);
				}
			}
		}

		private static void AnimateDashExtend(orig_OnEnter orig, ToolbotDash self)
		{
			orig.Invoke(self);
			if (!((EntityState)self).characterBody.IsLocalBody())
			{
				return;
			}
			if (isSwapping)
			{
				isSwapping = false;
				((MonoBehaviour)RoR2Application.instance).StartCoroutine(ExtendAfterDelay());
				return;
			}
			Animator animator = MotionControls.GetHandByDominance(dominant: false).animator;
			if (animator.GetInteger("ToolID") != 0)
			{
				animator.SetFloat("RetoolSpeed", 4f);
				animator.SetTrigger("RetoolRetract");
				((MonoBehaviour)RoR2Application.instance).StartCoroutine(ExtendAfterDelay());
			}
		}

		private static void ForceShotgunMuzzle(orig_FireBullet orig, GenericBulletBaseState self, Ray aimRay)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (!ModConfig.CommandoDualWield.Value && ((EntityState)self).characterBody.IsLocalBody() && self is FireShotgunBlast)
			{
				self.muzzleName = "MuzzleLeft";
			}
			orig.Invoke(self, aimRay);
		}

		private static void ShrinkChargeEffect(orig_OnEnter orig, ChargeCaptainShotgun self)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			foreach (Transform item in ChargeCaptainShotgun.holdChargeVfxPrefab.transform)
			{
				Transform val = item;
				if (!((Object)val).name.ToLower().Contains("light"))
				{
					val.localScale = new Vector3(0.5f, 0.5f, 0.5f);
				}
			}
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				foreach (Transform item2 in ChargeCaptainShotgun.chargeupVfxPrefab.transform)
				{
					Transform val2 = item2;
					if (!((Object)val2).name.ToLower().Contains("light"))
					{
						val2.localScale = new Vector3(0.5f, 0.5f, 0.5f);
					}
				}
			}
			orig.Invoke(self);
		}

		private static void ShrinkFireEffect(orig_OnEnter orig, Flamethrower self)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			Transform child = self.flamethrowerEffectPrefab.transform.GetChild(4);
			Transform child2 = self.flamethrowerEffectPrefab.transform.GetChild(5);
			child.localScale = new Vector3(0.15f, 0.15f, 0.15f);
			child2.localScale = new Vector3(0.15f, 0.15f, 0.15f);
			child.localPosition = Vector3.zero;
			child2.localPosition = Vector3.zero;
			orig.Invoke(self);
		}

		private static void AnimateShotgunShoot(orig_OnEnter orig, FireCaptainShotgun self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: true).animator.SetFloat("ShootSpeed", 1f / ((GenericBulletBaseState)self).duration);
				MotionControls.GetHandByDominance(dominant: true).animator.SetTrigger("Shoot");
			}
		}

		private static void AnimateAcridRest(orig_OnExit orig, BaseLeap self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: true).animator.SetTrigger("Rest");
				MotionControls.GetHandByDominance(dominant: false).animator.SetTrigger("Rest");
			}
		}

		private static void HideLoaderRay(orig_OnExit orig, BaseChargeFist self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: true).animator.SetBool("Ray", false);
			}
		}

		private static void ShowLoaderRay(orig_OnEnter orig, BaseChargeFist self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: true).animator.SetBool("Ray", true);
			}
		}

		private static void AnimateHookExit(orig_OnExit orig, FireHook self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: false).animator.SetBool("Hook", false);
			}
		}

		private static void AnimateHookEnter(orig_OnEnter orig, FireHook self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: false).animator.SetBool("Hook", true);
			}
		}

		private static void AnimateSonicBoom(orig_OnEnter orig, FireSonicBoom self)
		{
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: false).animator.SetTrigger("Push");
			}
			orig.Invoke(self);
		}

		private static void EndSyringeShoot(orig_OnExit orig, FireSyringe self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: true).animator.SetInteger("SyringeShots", 0);
				if (self.projectilesFired < FireSyringe.projectileCount)
				{
					MotionControls.GetHandByDominance(dominant: true).animator.SetTrigger("ForceReload");
				}
			}
		}

		private static void AnimateSyringeShoot(orig_FixedUpdate orig, FireSyringe self)
		{
			if (!((EntityState)self).characterBody.IsLocalBody())
			{
				orig.Invoke(self);
				return;
			}
			if (self.projectilesFired <= 0)
			{
				MotionControls.GetHandByDominance(dominant: true).animator.SetFloat("ReloadSpeed", ((BaseState)self).attackSpeedStat);
			}
			orig.Invoke(self);
			MotionControls.GetHandByDominance(dominant: true).animator.SetInteger("SyringeShots", self.projectilesFired);
		}

		private static void AnimateWallCast(orig_OnExit orig, PrepWall self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: false).animator.SetTrigger("Cast");
			}
		}

		private static void AnimateBombCast(orig_OnEnter orig, BaseThrowBombState self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody() && (self is ThrowNovabomb || self is ThrowIcebomb))
			{
				MotionControls.GetHandByDominance(dominant: false).animator.SetTrigger("Cast");
			}
		}

		private static void StopCastAnimation(orig_OnExit orig, Flamethrower self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: true).animator.ResetTrigger("Cast");
				MotionControls.GetHandByDominance(dominant: true).animator.SetBool("HoldCast", false);
			}
		}

		private static void AnimateBlueprintRelease(orig_OnExit orig, PlaceTurret self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: true).animator.SetTrigger("Release");
			}
		}

		private static void AnimateHarpoonRelease(orig_OnExit orig, Paint self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: true).animator.SetTrigger("Release");
			}
		}

		private static void AnimateGrenadeRelease(orig_OnExit orig, ChargeGrenades self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: true).animator.SetTrigger("Release");
			}
		}

		private static void ForceBuzzsawMuzzle(orig_OnEnter orig, BaseToolbotPrimarySkillState self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody() && self.baseMuzzleName == "MuzzleBuzzsaw" && self.isInDualWield)
			{
				self.muzzleName = self.baseMuzzleName;
				self.muzzleTransform = MotionControls.GetHandByDominance((Object)(object)((BaseSkillState)self).activatorSkillSlot == (Object)(object)((EntityState)self).skillLocator.primary).GetMuzzleByIndex(1u);
			}
		}

		private static void AnimateDualWieldEnd(orig_OnExit orig, ToolbotDualWield self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: false).animator.SetFloat("RetoolSpeed", 4f);
				((MonoBehaviour)RoR2Application.instance).StartCoroutine(ExtendAfterDelay());
			}
		}

		private static IEnumerator ExtendAfterDelay()
		{
			yield return (object)new WaitForSeconds(0.25f);
			MotionControls.GetHandByDominance(dominant: false).animator.SetInteger("ToolID", 0);
			MotionControls.GetHandByDominance(dominant: false).animator.SetTrigger("RetoolExtend");
		}

		private static void AnimateDualWieldExtend(orig_FixedUpdate orig, ToolbotDualWieldStart self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody() && ((FixedTimeStamp)(ref halfTime)).hasPassed && isSwapping)
			{
				isSwapping = false;
				GenericSkill primary2Slot = ((ToolbotDualWieldBase)self).primary2Slot;
				if (Object.op_Implicit((Object)(object)primary2Slot))
				{
					MotionControls.GetHandByDominance(dominant: false).animator.SetInteger("ToolID", Array.IndexOf(multPrimarySkills, primary2Slot.skillDef.skillName));
					MotionControls.GetHandByDominance(dominant: false).animator.SetTrigger("RetoolExtend");
				}
			}
		}

		private static void AnimateDualWieldRetract(orig_OnEnter orig, ToolbotDualWieldStart self)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				isSwapping = true;
				halfTime = FixedTimeStamp.now + self.duration / 2f;
				MotionControls.GetHandByDominance(dominant: false).animator.SetFloat("RetoolSpeed", 2f / self.duration);
				MotionControls.GetHandByDominance(dominant: false).animator.SetTrigger("RetoolRetract");
			}
		}

		private static void AnimateSawSlowdown(orig_OnExit orig, FireBuzzsaw self)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			orig.Invoke(self);
			CharacterBody characterBody = ((EntityState)self).characterBody;
			if (characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance((int)characterBody.skillLocator.FindSkillSlot(((BaseSkillState)self).activatorSkillSlot) == 0).animator.SetTrigger("BuzzsawSlowdown");
			}
		}

		private static void AnimateGrenadeThrow(orig_OnExit orig, AimStunDrone self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: true).animator.ResetTrigger("AimGrenade");
				MotionControls.GetHandByDominance(dominant: false).animator.SetTrigger("ThrowGrenade");
			}
		}

		private static void AnimateChargeSpear(orig_OnEnter orig, CooldownSpear self)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			orig.Invoke(self);
			CharacterBody characterBody = ((EntityState)self).characterBody;
			if (characterBody.IsLocalBody())
			{
				bool dominant = (int)characterBody.skillLocator.FindSkillSlot(((BaseSkillState)self).activatorSkillSlot) == 0;
				MotionControls.GetHandByDominance(dominant).animator.SetFloat("SpearChargeSpeed", 1f / self.duration);
				MotionControls.GetHandByDominance(dominant).animator.SetTrigger("SpearCharge");
			}
		}

		private static void SetInitialTool(CharacterBody body)
		{
			if (((Object)body).name == "ToolbotBody(Clone)")
			{
				GenericSkill primary = body.skillLocator.primary;
				if (Object.op_Implicit((Object)(object)primary))
				{
					MotionControls.GetHandByDominance(dominant: true).animator.SetInteger("ToolID", Array.IndexOf(multPrimarySkills, primary.skillDef.skillName));
				}
			}
		}

		private static void AnimateRetoolExtend(orig_FixedUpdate orig, ToolbotStanceSwap self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody() && ((FixedTimeStamp)(ref halfTime)).hasPassed && !isSwapping)
			{
				isSwapping = true;
				GenericSkill val = ((self.previousStanceState == typeof(ToolbotStanceA)) ? ((ToolbotStanceBase)self).GetPrimarySkill2() : ((ToolbotStanceBase)self).GetPrimarySkill1());
				if (Object.op_Implicit((Object)(object)val))
				{
					MotionControls.GetHandByDominance(dominant: true).animator.SetInteger("ToolID", Array.IndexOf(multPrimarySkills, val.skillDef.skillName));
					MotionControls.GetHandByDominance(dominant: true).animator.SetTrigger("RetoolExtend");
				}
			}
		}

		private static void AnimateRetoolRetract(orig_OnEnter orig, ToolbotStanceSwap self)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				isSwapping = false;
				halfTime = FixedTimeStamp.now + self.baseDuration / (((BaseState)self).attackSpeedStat * 2f);
				MotionControls.GetHandByDominance(dominant: true).animator.SetFloat("RetoolSpeed", 2f / (self.baseDuration / ((BaseState)self).attackSpeedStat));
				MotionControls.GetHandByDominance(dominant: true).animator.SetTrigger("RetoolRetract");
			}
		}

		private static void AnimateSpinDown(orig_OnExit orig, FireNailgun self)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			orig.Invoke(self);
			CharacterBody characterBody = ((EntityState)self).characterBody;
			if (characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance((int)characterBody.skillLocator.FindSkillSlot(((BaseSkillState)self).activatorSkillSlot) == 0).animator.SetTrigger("NailgunSlowdown");
			}
		}

		private static void DeleteEffect(orig_OnEnter orig, ThrowGlaive self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody() && Object.op_Implicit((Object)(object)self.chargeEffect))
			{
				EntityState.Destroy((Object)(object)self.chargeEffect);
			}
		}

		private static void AnimateGlaiveThrow(orig_FireOrbGlaive orig, ThrowGlaive self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody() && self.hasSuccessfullyThrownGlaive)
			{
				MotionControls.GetHandByDominance(dominant: false).animator.SetTrigger("ThrowGlaive");
			}
		}

		private static void PlayRevolverSpinAnimation(orig_OnEnter orig, BasePrepSidearmRevolverState self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: true).animator.SetFloat("SpinSpeed", 1f / ((BaseSidearmState)self).duration);
				MotionControls.GetHandByDominance(dominant: true).animator.SetTrigger("RevolverSpin");
			}
		}

		private static void ChangeNeedleMuzzle(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.GotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdstr(x, "Head")
			});
			val.Remove();
			val.Emit(OpCodes.Ldarg_0);
			val.EmitDelegate<Func<FireLunarNeedle, string>>((Func<FireLunarNeedle, string>)((FireLunarNeedle self) => (!((EntityState)self).characterBody.IsLocalBody()) ? "Head" : "CurrentDominantMuzzle"));
		}

		private static void ChangeTazerMuzzleShoot(orig_Fire orig, FireTazer self)
		{
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: false).animator.SetTrigger("Rest");
				string targetMuzzle = FireTazer.targetMuzzle;
				FireTazer.targetMuzzle = "CurrentNonDominantMuzzle";
				orig.Invoke(self);
				FireTazer.targetMuzzle = targetMuzzle;
			}
			else
			{
				orig.Invoke(self);
			}
		}

		private static void ChangeTazerMuzzleEnter(orig_OnEnter orig, FireTazer self)
		{
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				string targetMuzzle = FireTazer.targetMuzzle;
				FireTazer.targetMuzzle = "CurrentNonDominantMuzzle";
				orig.Invoke(self);
				FireTazer.targetMuzzle = targetMuzzle;
			}
			else
			{
				orig.Invoke(self);
			}
		}

		private static void ChangeBiteDirection(orig_OnEnter orig, Bite self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				((BasicMeleeAttack)self).swingEffectMuzzleString = "MuzzleHandL";
			}
		}

		private static void ForceDashDirection(orig_OnEnter orig, Assaulter2 self)
		{
			//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)
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				self.dashVector = MotionControls.GetHandByDominance(dominant: false).muzzle.forward;
			}
		}

		private static void ForceFocusedDashDirection(orig_OnEnter orig, FocusedAssaultDash self)
		{
			//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)
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				self.dashVector = MotionControls.GetHandByDominance(dominant: false).muzzle.forward;
			}
		}

		private static void ForceWhirlwindDirection(orig_FixedUpdate orig, WhirlwindBase self)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (((EntityState)self).characterBody.IsLocalBody() && Object.op_Implicit((Object)(object)((EntityState)self).characterDirection))
			{
				((EntityState)self).characterDirection.forward = abilityDirection;
			}
			orig.Invoke(self);
		}

		private static void ChangeSlashDirection(orig_OnEnter orig, SlashBlade self)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				abilityDirection = MotionControls.GetHandByDominance(dominant: false).muzzle.forward;
				if (Object.op_Implicit((Object)(object)((EntityState)self).characterDirection))
				{
					((EntityState)self).characterDirection.forward = abilityDirection;
				}
			}
		}

		private static void ChangeUppercutDirection(orig_OnEnter orig, Uppercut self)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				abilityDirection = MotionControls.GetHandByDominance(dominant: false).muzzle.forward;
				if (Object.op_Implicit((Object)(object)((EntityState)self).characterDirection))
				{
					((EntityState)self).characterDirection.forward = abilityDirection;
				}
			}
		}

		private static void ChangeWhirlwindDirection(orig_OnEnter orig, WhirlwindBase self)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				abilityDirection = MotionControls.GetHandByDominance(dominant: false).muzzle.forward;
				if (Object.op_Implicit((Object)(object)((EntityState)self).characterDirection))
				{
					((EntityState)self).characterDirection.forward = abilityDirection;
				}
			}
		}

		private static void SetFireboltMuzzle(orig_FireGauntlet orig, FireFireBolt self)
		{
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				self.muzzleString = "MuzzleRight";
			}
			orig.Invoke(self);
		}

		private static void RemoveMuzzleFlash(orig_FireGrenade orig, FireGrenades self, string targetMuzzle)
		{
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				GameObject effectPrefab = FireGrenades.effectPrefab;
				FireGrenades.effectPrefab = null;
				orig.Invoke(self, targetMuzzle);
				FireGrenades.effectPrefab = effectPrefab;
			}
			else
			{
				orig.Invoke(self, targetMuzzle);
			}
		}

		private static Ray GetLeftAimRay(orig_GetAimRay orig, EquipmentSlot self)
		{
			//IL_001b: 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)
			if (self.characterBody.IsLocalBody())
			{
				return MotionControls.GetHandBySide(left: true).aimRay;
			}
			return orig.Invoke(self);
		}

		private static Ray CancelModifyIfLocal(orig_ModifyAimRayIfApplicable orig, Ray originalAimRay, GameObject target, out float extraRaycastDistance)
		{
			//IL_0052: 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_004f: 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)
			CharacterBody component = target.GetComponent<CharacterBody>();
			if (Object.op_Implicit((Object)(object)component) && component.IsLocalBody())
			{
				extraRaycastDistance = 0f;
				Type declaringType = new StackTrace().GetFrame(2).GetMethod().DeclaringType;
				if (forceAimRaySideTypes.TryGetValue(declaringType, out var value))
				{
					return MotionControls.GetHandBySide(value).aimRay;
				}
				return originalAimRay;
			}
			return orig.Invoke(originalAimRay, target, ref extraRaycastDistance);
		}

		private static void PingFromHand(orig_CheckPinging orig, PlayerCharacterMasterController self)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			if (!self.body.IsLocalBody())
			{
				orig.Invoke(self);
			}
			else if (self.hasEffectiveAuthority && Object.op_Implicit((Object)(object)self.body) && Object.op_Implicit((Object)(object)self.bodyInputs) && ((ButtonState)(ref self.bodyInputs.ping)).justPressed)
			{
				self.pingerController.AttemptPing(MotionControls.GetHandBySide(left: false).aimRay, ((Component)self.body).gameObject);
			}
		}

		private static void SetNailgunMuzzle(orig_FireBullet orig, BaseNailgunState self, Ray aimRay, int bulletCount, float spreadPitchScale, float spreadYawScale)
		{
			//IL_002c: 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)
			if (!((EntityState)self).characterBody.IsLocalBody())
			{
				orig.Invoke(self, aimRay, bulletCount, spreadPitchScale, spreadYawScale);
			}
			string muzzleName = BaseNailgunState.muzzleName;
			BaseNailgunState.muzzleName = ((IToolbotPrimarySkillState)self).muzzleName;
			orig.Invoke(self, aimRay, bulletCount, spreadPitchScale, spreadYawScale);
			BaseNailgunState.muzzleName = muzzleName;
		}

		private static void SetGrenadeMuzzle(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.GotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdstr(x, "MuzzleNailgun")
			});
			val.Remove();
			val.Emit(OpCodes.Ldarg_0);
			val.EmitDelegate<Func<RecoverAimStunDrone, string>>((Func<RecoverAimStunDrone, string>)((RecoverAimStunDrone self) => (!((EntityState)self).characterBody.IsLocalBody()) ? "MuzzleNailgun" : "CurrentNonDominantMuzzle"));
		}

		private static void SetRebarMuzzle(orig_FireBullet orig, FireSpear self, Ray aimRay)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				((GenericBulletBaseState)self).muzzleName = ((IToolbotPrimarySkillState)self).muzzleName;
			}
			orig.Invoke(self, aimRay);
		}

		private static void SetScrapMuzzle(orig_OnEnter orig, FireGrenadeLauncher self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				((GenericProjectileBaseState)self).targetMuzzle = ((IToolbotPrimarySkillState)self).muzzleName;
			}
		}

		private static Vector3 GetNonDominantVector(orig_GetBlinkVector orig, BlinkState self)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				return MotionControls.GetHandByDominance(dominant: false).muzzle.forward;
			}
			return orig.Invoke(self);
		}

		private static Ray EditAimray(orig_GetAimRay orig, BaseState self)
		{
			//IL_0093: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				bool flag = ((Object)((EntityState)self).characterBody).name.Contains("ToolbotBody");
				if (nonDominantHandStateTypes.Contains(((object)self).GetType()) || (flag && ((EntityState)self).outer.customName == "Weapon2"))
				{
					return MotionControls.GetHandByDominance(dominant: false).aimRay;
				}
				if (flag && self is GenericProjectileBaseState)
				{
					GenericProjectileBaseState val = (GenericProjectileBaseState)self;
					if (flag && val.targetMuzzle == "DualWieldMuzzleR")
					{
						return MotionControls.GetHandByDominance(dominant: false).aimRay;
					}
				}
			}
			return orig.Invoke(self);
		}

		private static void HideArrowCluster(orig_OnExit orig, BaseArrowBarrage self)
		{
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: true).animator.SetBool("ShowCluster", false);
			}
			orig.Invoke(self);
		}

		private static void AnimateSnipeBow(orig_HandlePrimaryAttack orig, AimArrowSnipe self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: true).animator.SetTrigger("Primary");
				if (self.primarySkillSlot.stock > 0)
				{
					MotionControls.GetHandByDominance(dominant: true).animator.SetTrigger("Pull");
				}
			}
		}

		private static void AnimateBarrageBowShoot(orig_HandlePrimaryAttack orig, BaseArrowBarrage self)
		{
			orig.Invoke(self);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: true).animator.SetTrigger("Primary");
			}
		}

		private static void AnimateBarrageBowPull(orig_OnEnter orig, BaseArrowBarrage self)
		{
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: true).animator.SetBool("ShowCluster", true);
				MotionControls.GetHandByDominance(dominant: true).animator.SetTrigger("Pull");
			}
			orig.Invoke(self);
		}

		private static void PreventBowPull(orig_OnExit orig, FireSeekingArrow self)
		{
			if (!((EntityState)self).characterBody.IsLocalBody())
			{
				orig.Invoke(self);
			}
			preventBowPull = true;
			orig.Invoke(self);
			preventBowPull = false;
		}

		private static void AnimatePrimaryBowShoot(orig_FireOrbArrow orig, FireSeekingArrow self)
		{
			int firedArrowCount = self.firedArrowCount;
			orig.Invoke(self);
			if (self.firedArrowCount > firedArrowCount && ((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: true).animator.SetTrigger("Primary");
				if (!preventBowPull && self.firedArrowCount < self.maxArrowCount)
				{
					MotionControls.GetHandByDominance(dominant: true).animator.SetTrigger("Pull");
				}
			}
		}

		private static void SprintBreakDirection(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.GotoNext(new Func<Instruction, bool>[3]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchLdfld<PlayerCharacterMasterController>(x, "bodyInputs"),
				(Instruction x) => ILPatternMatchingExt.MatchCallvirt<InputBankTest>(x, "get_aimDirection")
			});
			val.RemoveRange(3);
			val.Emit(OpCodes.Ldloc_S, (byte)14);
			val.EmitDelegate<Func<CameraRigController, Vector3>>((Func<CameraRigController, Vector3>)((CameraRigController rig) => ((Component)rig.sceneCam).transform.forward));
			for (int num = 0; num < 4; num++)
			{
				val.GotoNext(new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchCallvirt(x, typeof(Player), "GetButton")
				});
				val.Remove();
				val.EmitDelegate<Func<Player, int, bool>>((Func<Player, int, bool>)((Player player, int button) => player.GetButton(button) || MeleeSkill.skillStates[button - 7]));
			}
		}

		private static void PlayFMJShootAnimation(orig_PlayAnimation orig, FireFMJ self, float duration)
		{
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: false).animator.SetTrigger("Primary");
			}
			orig.Invoke(self, duration);
		}

		private static void PlayBarrageShootAnimation(orig_FireBullet orig, FireBarrage self)
		{
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				MotionControls.GetHandByDominance(dominant: true).animator.SetTrigger("Primary");
			}
			orig.Invoke(self);
		}

		private static void DestroyOffHandEffect(orig_FireGauntlet orig, Flamethrower self, string muzzleString)
		{
			orig.Invoke(self, muzzleString);
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				if (Object.op_Implicit((Object)(object)self.leftFlamethrowerTransform))
				{
					Object.Destroy((Object)(object)((Component)self.leftFlamethrowerTransform).gameObject);
				}
				MotionControls.GetHandByDominance(dominant: true).animator.SetBool("HoldCast", true);
				MotionControls.GetHandByDominance(dominant: true).animator.SetTrigger("Cast");
			}
		}

		private static void SetFMJMuzzle(orig_FireProjectile orig, GenericProjectileBaseState self)
		{
			if (((EntityState)self).characterBody.IsLocalBody() && self is FireFMJ)
			{
				self.targetMuzzle = "MuzzleLeft";
			}
			orig.Invoke(self);
		}

		private static BulletAttack ChangeShotgunMuzzle(orig_GenerateBulletAttack orig, GenericBulletBaseState self, Ray aimRay)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (((EntityState)self).characterBody.IsLocalBody() && self is FireShotgunBlast)
			{
				if (!ModConfig.CommandoDualWield.Value)
				{
					self.muzzleName = "MuzzleLeft";
				}
				if (self.muzzleName == "MuzzleLeft")
				{
					aimRay = MotionControls.GetHandByDominance(dominant: false).aimRay;
				}
				Animator animator = MotionControls.GetHandByDominance(!self.muzzleName.Contains("Left") && ModConfig.CommandoDualWield.Value).animator;
				if (Object.op_Implicit((Object)(object)animator))
				{
					animator.SetTrigger("Primary");
				}
			}
			return orig.Invoke(self, aimRay);
		}

		private static void CheckPistolBulletMuzzle(orig_FireBullet orig, FirePistol2 self, string targetMuzzle)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (((EntityState)self).characterBody.IsLocalBody())
			{
				if (!ModConfig.CommandoDualWield.Value)
				{
					targetMuzzle = "MuzzleRight";
				}
				if (targetMuzzle.Contains("Left"))
				{
					self.aimRay = MotionControls.GetHandByDominance(dominant: false).aimRay;
					Animator animator = MotionControls.GetHandByDominance(dominant: false).animator;
					if (Object.op_Implicit((Object)(object)animator))
					{
						animator.SetTrigger("Primary");
					}
				}
				else
				{
					Animator animator2 = MotionControls.GetHandByDominance(dominant: true).animator;
					if (Object.op_Implicit((Object)(object)animator2))
					{
						animator2.SetTrigger("Primary");
					}
				}
			}
			orig.Invoke(self, targetMuzzle);
		}
	}
	public static class MotionControls
	{
		public delegate void SetHandPairEventHandler(CharacterBody body);

		internal delegate void SkinAppliedEventHandler(SkinDef skinDef);

		internal struct HUDQueueEntry
		{
			internal RectTransform transform;

			internal bool left;

			internal HUDQueueEntry(RectTransform transform, bool left)
			{
				this.transform = transform;
				this.left = left;
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Start <0>__InitHandsAndHUDs;

			public static hook_OnSprintStart <1>__OnSprintStart;

			public static hook_OnSprintStop <2>__OnSprintStop;

			public static hook_UpdateMaterials <3>__UpdateHandMaterials;

			public static hook_OnInventoryChanged <4>__OnInventoryChanged;

			public static Action <5>__UpdateForcedAimRay;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Action<CharacterBody> <>9__22_2;

			public static Action<PlayerCharacterMasterController> <>9__22_0;

			public static hook_ApplySkin <>9__22_1;

			public static Func<GameObject, bool> <>9__46_0;

			public static Func<GameObject, bool> <>9__46_1;

			public static Predicate<NameTransformPair> <>9__48_0;

			public static Predicate<NameTransformPair> <>9__48_1;

			public static Predicate<NameTransformPair> <>9__48_2;

			internal void <Init>b__22_0(PlayerCharacterMasterController pcmc)
			{
				pcmc.master.onBodyStart += delegate(CharacterBody body)
				{
					if (body.master.IsLocalMaster() && !((Object)(object)body == (Object)(object)currentBody))
					{
						currentBody = body;
						string text = ((Object)body).name.Substring(0, ((Object)body).name.IndexOf("(Clone)"));
						VRMod.StaticLogger.LogInfo((object)$"Local cached body '{text}' found. Applying hand pair.");
						SetHandPair(body);
						Controllers.ApplyRemaps(text);
					}
				};
			}

			internal void <Init>b__22_2(CharacterBody body)
			{
				if (body.master.IsLocalMaster() && !((Object)(object)body == (Object)(object)currentBody))
				{
					currentBody = body;
					string text = ((Object)body).name.Substring(0, ((Object)body).name.IndexOf("(Clone)"));
					VRMod.StaticLogger.LogInfo((object)$"Local cached body '{text}' found. Applying hand pair.");
					SetHandPair(body);
					Controllers.ApplyRemaps(text);
				}
			}

			internal void <Init>b__22_1(orig_ApplySkin orig, ModelSkinController self, int index)
			{
				orig.Invoke(self, index);
				if (index == self.currentSkinIndex && (Object)(object)self.characterModel.body == (Object)(object)currentBody && onSkinApplied != null)
				{
					onSkinApplied(self.skins[index]);
				}
			}

			internal bool <SetupHands>b__46_0(GameObject x)
			{
				return CheckDominance(x, dominant: true);
			}

			internal bool <SetupHands>b__46_1(GameObject x)
			{
				return CheckDominance(x, dominant: false);
			}

			internal bool <SetHandPair>b__48_0(NameTransformPair x)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return x.name == "CurrentDominantMuzzle";
			}

			internal bool <SetHandPair>b__48_1(NameTransformPair x)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return x.name == "CurrentDominantMuzzle";
			}

			internal bool <SetHandPair>b__48_2(NameTransformPair x)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return x.name == "CurrentNonDominantMuzzle";
			}
		}

		private static GameObject handControllerPrefab;

		private static HandController dominantHand;

		private static HandController nonDominantHand;

		private static List<GameObject> handPrefabs = new List<GameObject>();

		private static Image cachedSprintIcon;

		private static Color originalSprintIconColor;

		public static SetHandPairEventHandler onHandPairSet;

		internal static SkinAppliedEventHandler onSkinApplied;

		internal static CharacterBody currentBody;

		private static List<HUDQueueEntry> wristHudQueue = new List<HUDQueueEntry>();

		private static List<HUDQueueEntry> watchHudQueue = new List<HUDQueueEntry>();

		private static TwoHandedMainHand banditMainHand;

		private static MeleeSkill mercMelee;

		private static MeleeSkill[] loaderMelee;

		private static MeleeSkill[] acridMelee;

		private static TwoHandedMainHand railgunnerMainHand;

		private static bool isBanditTweaksInstalled;

		public static bool HandsReady
		{
			get
			{
				if ((Object)(object)dominantHand != (Object)null && (Object)(object)nonDominantHand != (Object)null && (Object)(object)dominantHand.currentHand != (Object)null && (Object)(object)nonDominantHand.currentHand != (Object)null && ((Behaviour)dominantHand).isActiveAndEnabled)
				{
					return ((Behaviour)nonDominantHand).isActiveAndEnabled;
				}
				return false;
			}
		}

		internal static void Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//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_005b: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			object obj = <>O.<0>__InitHandsAndHUDs;
			if (obj == null)
			{
				hook_Start val = InitHandsAndHUDs;
				<>O.<0>__InitHandsAndHUDs = val;
				obj = (object)val;
			}
			CameraRigController.Start += (hook_Start)obj;
			object obj2 = <>O.<1>__OnSprintStart;
			if (obj2 == null)
			{
				hook_OnSprintStart val2 = OnSprintStart;
				<>O.<1>__OnSprintStart = val2;
				obj2 = (object)val2;
			}
			CharacterBody.OnSprintStart += (hook_OnSprintStart)obj2;
			object obj3 = <>O.<2>__OnSprintStop;
			if (obj3 == null)
			{
				hook_OnSprintStop val3 = OnSprintStop;
				<>O.<2>__OnSprintStop = val3;
				obj3 = (object)val3;
			}
			CharacterBody.OnSprintStop += (hook_OnSprintStop)obj3;
			object obj4 = <>O.<3>__UpdateHandMaterials;
			if (obj4 == null)
			{
				hook_UpdateMaterials val4 = UpdateHandMaterials;
				<>O.<3>__UpdateHandMaterials = val4;
				obj4 = (object)val4;
			}
			CharacterModel.UpdateMaterials += (hook_UpdateMaterials)obj4;
			PlayerCharacterMasterController.onPlayerAdded += delegate(PlayerCharacterMasterController pcmc)
			{
				pcmc.master.onBodyStart += delegate(CharacterBody body)
				{
					if (body.master.IsLocalMaster() && !((Object)(object)body == (Object)(object)currentBody))
					{
						currentBody = body;
						string text2 = ((Object)body).name.Substring(0, ((Object)body).name.IndexOf("(Clone)"));
						VRMod.StaticLogger.LogInfo((object)$"Local cached body '{text2}' found. Applying hand pair.");
						SetHandPair(body);
						Controllers.ApplyRemaps(text2);
					}
				};
			};
			object obj5 = <>c.<>9__22_1;
			if (obj5 == null)
			{
				hook_ApplySkin val5 = delegate(orig_ApplySkin orig, ModelSkinController self, int index)
				{
					orig.Invoke(self, index);
					if (index == self.currentSkinIndex && (Object)(object)self.characterModel.body == (Object)(object)currentBody && onSkinApplied != null)
					{
						onSkinApplied(self.skins[index]);
					}
				};
				<>c.<>9__22_1 = val5;
				obj5 = (object)val5;
			}
			ModelSkinController.ApplySkin += (hook_ApplySkin)obj5;
			object obj6 = <>O.<4>__OnInventoryChanged;
			if (obj6 == null)
			{
				hook_OnInventoryChanged val6 = OnInventoryChanged;
				<>O.<4>__OnInventoryChanged = val6;
				obj6 = (object)val6;
			}
			CharacterBody.OnInventoryChanged += (hook_OnInventoryChanged)obj6;
			handControllerPrefab = VRMod.VRAssetBundle.LoadAsset<GameObject>("VRHand");
			string[] obj7 = new string[26]
			{
				"CommandoPistol", "HuntressBow", "HuntressHand", "BanditRifle", "BanditHand", "MULTTools", "MULTTools2", "EngiHand", "EngiHand2", "ArtiHand",
				"ArtiHand2", "MercHand", "MercSword", "RexGun", "RexFlower", "LoaderHand", "LoaderHand2", "AcridHand", "AcridHand2", "CaptainHand",
				"CaptainGun", "HereticWing", "VoidFiendStub", "VoidFiendHand", "RailgunnerRifle", "RailgunnerHand"
			};
			loaderMelee = new MeleeSkill[2];
			acridMelee = new MeleeSkill[2];
			string[] array = obj7;
			foreach (string text in array)
			{
				GameObject val7 = VRMod.VRAssetBundle.LoadAsset<GameObject>(text);
				if (Object.op_Implicit((Object)(object)val7))
				{
					switch (text)
					{
					case "BanditRifle":
						banditMainHand = val7.GetComponent<TwoHandedMainHand>();
						banditMainHand.snapAngle = ModConfig.BanditWeaponGripSnapAngle.Value;
						break;
					case "MercSword":
						mercMelee = val7.GetComponent<MeleeSkill>();
						mercMelee.speedThreshold = ModConfig.MercSwingSpeedThreshold.Value;
						break;
					case "LoaderHand":
						loaderMelee[0] = val7.GetComponent<MeleeSkill>();
						loaderMelee[0].speedThreshold = ModConfig.LoaderSwingSpeedThreshold.Value;
						break;
					case "LoaderHand2":
						loaderMelee[1] = val7.GetComponent<MeleeSkill>();
						loaderMelee[1].speedThreshold = ModConfig.LoaderSwingSpeedThreshold.Value;
						break;
					case "AcridHand":
						acridMelee[0] = val7.GetComponent<MeleeSkill>();
						acridMelee[0].speedThreshold = ModConfig.AcridSwingSpeedThreshold.Value;
						break;
					case "AcridHand2":
						acridMelee[1] = val7.GetComponent<MeleeSkill>();
						acridMelee[1].speedThreshold = ModConfig.AcridSwingSpeedThreshold.Value;
						break;
					case "RailgunnerRifle":
						railgunnerMainHand = val7.GetComponent<TwoHandedMainHand>();
						railgunnerMainHand.snapAngle = ModConfig.RailgunnerWeaponGripSnapAngle.Value;
						break;
					}
					AddHandPrefab(val7);
				}
			}
			isBanditTweaksInstalled = Chainloader.PluginInfos.ContainsKey("com.Moffein.BanditTweaks");
		}

		internal static void UpdateDominance()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: 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_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			if (HandsReady)
			{
				HandHUD smallHud = dominantHand.smallHud;
				Vector3 localPosition = ((Component)smallHud).transform.localPosition;
				Quaternion localRotation = ((Component)smallHud).transform.localRotation;
				HandHUD smallHud2 = nonDominantHand.smallHud;
				Vector3 localPosition2 = ((Component)smallHud2).transform.localPosition;
				Quaternion localRotation2 = ((Component)smallHud2).transform.localRotation;
				HandHUD watchHud = dominantHand.watchHud;
				Vector3 localPosition3 = ((Component)watchHud).transform.localPosition;
				Quaternion localRotation3 = ((Component)watchHud).transform.localRotation;
				HandHUD watchHud2 = nonDominantHand.watchHud;
				Vector3 localPosition4 = ((Component)watchHud2).transform.localPosition;
				Quaternion localRotation4 = ((Component)watchHud2).transform.localRotation;
				((Component)smallHud).transform.SetParent((Transform)null);
				((Component)smallHud2).transform.SetParent((Transform)null);
				((Component)watchHud).transform.SetParent((Transform)null);
				((Component)watchHud2).transform.SetParent((Transform)null);
				Vector3 localScale = ((Component)dominantHand).transform.localScale;
				((Component)nonDominantHand).transform.localScale = localScale;
				localScale.x *= -1f;
				((Component)dominantHand).transform.localScale = localScale;
				dominantHand.xrNode = (XRNode)(ModConfig.LeftDominantHand.Value ? 4 : 5);
				nonDominantHand.xrNode = (XRNode)(ModConfig.LeftDominantHand.Value ? 5 : 4);
				((Component)smallHud2).transform.SetParent(((Component)dominantHand).transform);
				((Component)smallHud2).transform.localPosition = localPosition;
				((Component)smallHud2).transform.localRotation = localRotation;
				dominantHand.smallHud = smallHud2;
				((Component)smallHud).transform.SetParent(((Component)nonDominantHand).transform);
				((Component)smallHud).transform.localPosition = localPosition2;
				((Component)smallHud).transform.localRotation = localRotation2;
				nonDominantHand.smallHud = smallHud;
				((Component)watchHud2).transform.SetParent(((Component)dominantHand).transform);
				((Component)watchHud2).transform.localPosition = localPosition3;
				((Component)watchHud2).transform.localRotation = localRotation3;
				dominantHand.watchHud = watchHud2;
				((Component)watchHud).transform.SetParent(((Component)nonDominantHand).transform);
				((Component)watchHud).transform.localPosition = localPosition4;
				((Component)watchHud).transform.localRotation = localRotation4;
				nonDominantHand.watchHud = watchHud;
				if (((Object)currentBody).name.Contains("RailgunnerBody"))
				{
					((Component)dominantHand.currentHand).GetComponent<SniperScopeController>().UpdateDominance(ModConfig.LeftDominantHand.Value);
				}
			}
		}

		internal static void UpdateRayColor()
		{
			dominantHand.UpdateRayColor();
			nonDominantHand.UpdateRayColor();
		}

		internal static void UpdateBanditSnapAngle(object sender, EventArgs e)
		{
			if (ModConfig.MotionControlsEnabled)
			{
				banditMainHand.snapAngle = ModConfig.BanditWeaponGripSnapAngle.Value;
				UpdateTwoHandedSnapAngleOnCurrentHand(dominant: true, "BanditRifle", ModConfig.BanditWeaponGripSnapAngle.Value);
			}
		}

		internal static void UpdateMercMeleeThreshold(object sender, EventArgs e)
		{
			if (ModConfig.MotionControlsEnabled)
			{
				mercMelee.speedThreshold = ModConfig.MercSwingSpeedThreshold.Value;
				UpdateMeleeThresholdOnCurrentHand(dominant: true, "MercSword", ModConfig.MercSwingSpeedThreshold.Value);
			}
		}

		internal static void UpdateLoaderMeleeThreshold(object sender, EventArgs e)
		{
			if (ModConfig.MotionControlsEnabled)
			{
				for (int i = 0; i < loaderMelee.Length; i++)
				{
					loaderMelee[i].speedThreshold = ModConfig.LoaderSwingSpeedThreshold.Value;
				}
				UpdateMeleeThresholdOnCurrentHand(dominant: true, "LoaderHand", ModConfig.LoaderSwingSpeedThreshold.Value);
				UpdateMeleeThresholdOnCurrentHand(dominant: false, "LoaderHand", ModConfig.LoaderSwingSpeedThreshold.Value);
			}
		}

		internal static void UpdateAcridMeleeThreshold(object sender, EventArgs e)
		{
			if (ModConfig.MotionControlsEnabled)
			{
				for (int i = 0; i < acridMelee.Length; i++)
				{
					acridMelee[i].speedThreshold = ModConfig.LoaderSwingSpeedThreshold.Value;
				}
				UpdateMeleeThresholdOnCurrentHand(dominant: true, "AcridHand", ModConfig.AcridSwingSpeedThreshold.Value);
				UpdateMeleeThresholdOnCurrentHand(dominant: false, "AcridHand", ModConfig.AcridSwingSpeedThreshold.Value);
			}
		}

		internal static void UpdateRailgunnerSnapAngle(object sender, EventArgs e)
		{
			if (ModConfig.MotionControlsEnabled)
			{
				railgunnerMainHand.snapAngle = ModConfig.RailgunnerWeaponGripSnapAngle.Value;
				UpdateTwoHandedSnapAngleOnCurrentHand(dominant: true, "RailgunnerRifle", ModConfig.RailgunnerWeaponGripSnapAngle.Value);
			}
		}

		private static void UpdateMeleeThresholdOnCurrentHand(bool dominant, string expectedName, float threshold)
		{
			if (HandsReady && ((Object)((Component)(dominant ? dominantHand : nonDominantHand).currentHand).gameObject).name.Contains(expectedName))
			{
				((Component)(dominant ? dominantHand : nonDominantHand).currentHand).GetComponent<MeleeSkill>().speedThreshold = threshold;
			}
		}

		private static void UpdateTwoHandedSnapAngleOnCurrentHand(bool dominant, string expectedName, float angle)
		{
			if (HandsReady && ((Object)((Component)(dominant ? dominantHand : nonDominantHand).currentHand).gameObject).name.Contains(expectedName))
			{
				((Component)(dominant ? dominantHand : nonDominantHand).currentHand).GetComponent<TwoHandedMainHand>().snapAngle = angle;
			}
		}

		private static void OnInventoryChanged(orig_OnInventoryChanged orig, CharacterBody self)
		{
			orig.Invoke(self);
			if (!((Object)(object)self != (Object)(object)currentBody))
			{
				RoR2Application.onNextUpdate += UpdateForcedAimRay;
			}
		}

		private static void UpdateForcedAimRay()
		{
			//IL_004d: 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_00eb: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)currentBody))
			{
				EquipmentDef[] source = new EquipmentDef[6]
				{
					Equipment.Blackhole,
					Equipment.BFG,
					Equipment.GoldGat,
					Equipment.CrippleWard,
					Equipment.Gateway,
					Equipment.Saw
				};
				EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(currentBody.inventory.currentEquipmentIndex);
				dominantHand.hasAimableEquipment = false;
				nonDominantHand.hasAimableEquipment = false;
				dominantHand.hasAimableHeresySkill = false;
				nonDominantHand.hasAimableHeresySkill = false;
				if (((IEnumerable<EquipmentDef>)(object)source).Contains(equipmentDef))
				{
					((ModConfig.LeftDominantHand.Value != ((Object)(object)equipmentDef == (Object)(object)Equipment.GoldGat)) ? dominantHand : nonDominantHand).hasAimableEquipment = true;
				}
				if (currentBody.inventory.GetItemCount(Items.LunarPrimaryReplacement.itemIndex) > 0)
				{
					dominantHand.hasAimableHeresySkill = true;
				}
				if (currentBody.inventory.GetItemCount(Items.LunarSecondaryReplacement.itemIndex) > 0)
				{
					nonDominantHand.hasAimableHeresySkill = true;
				}
			}
		}

		internal static void SetSprintIcon(Image sprintIcon)
		{
			cachedSprintIcon = sprintIcon;
		}

		private static void OnSprintStop(orig_OnSprintStop orig, CharacterBody self)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (self.IsLocalBody())
			{
				if (Object.op_Implicit((Object)(object)cachedSprintIcon))
				{
					((Graphic)cachedSprintIcon).color = originalSprintIconColor;
				}
				if (((Object)self).name.Contains("Bandit2") && !isBanditTweaksInstalled)
				{
					GetHandByDominance(dominant: true).animator.SetBool("IsSprinting", false);
				}
			}
			orig.Invoke(self);
		}

		private static void OnSprintStart(orig_OnSprintStart orig, CharacterBody self)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			if (self.IsLocalBody())
			{
				if (!Object.op_Implicit((Object)(object)cachedSprintIcon))
				{
					Transform val = Utils.localCameraRig.hud.mainUIPanel.transform.Find("SpringCanvas/BottomRightCluster/Scaler/SprintCluster/SprintIcon");
					if (Object.op_Implicit((Object)(object)val))
					{
						Image component = ((Component)val).GetComponent<Image>();
						if (Object.op_Implicit((Object)(object)component))
						{
							cachedSprintIcon = component;
						}
					}
				}
				if (Object.op_Implicit((Object)(object)cachedSprintIcon))
				{
					originalSprintIconColor = ((Graphic)cachedSprintIcon).color;
					((Graphic)cachedSprintIcon).color = Color.yellow;
				}
				if (((Object)self).name.Contains("Bandit2") && !isBanditTweaksInstalled)
				{
					GetHandByDominance(dominant: true).animator.SetBool("IsSprinting", true);
				}
			}
			orig.Invoke(self);
		}

		private static void UpdateHandMaterials(orig_UpdateMaterials orig, CharacterModel self)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			if (!HandsReady || !self.body.IsLocalBody() || (int)self.visibility == 0)
			{
				return;
			}
			RendererInfo[] rendererInfos = dominantHand.currentHand.rendererInfos;
			foreach (RendererInfo val in rendererInfos)
			{
				if (Object.op_Implicit((Object)(object)val.renderer) && Object.op_Implicit((Object)(object)val.defaultMaterial))
				{
					self.UpdateRendererMaterials(val.renderer, val.defaultMaterial, val.ignoreOverlays);
				}
			}
			rendererInfos = nonDominantHand.currentHand.rendererInfos;
			foreach (RendererInfo val2 in rendererInfos)
			{
				if (Object.op_Implicit((Object)(object)val2.renderer) && Object.op_Implicit((Object)(object)val2.defaultMaterial))
				{
					self.UpdateRendererMaterials(val2.renderer, val2.defaultMaterial, val2.ignoreOverlays);
				}
			}
		}

		internal static void AddWristHUD(bool left, RectTransform hudCluster)
		{
			if (HandsReady)
			{
				((left == ModConfig.LeftDominantHand.Value) ? dominantHand : nonDominantHand).smallHud.AddHUDCluster(hudCluster);
			}
			else
			{
				wristHudQueue.Add(new HUDQueueEntry(hudCluster, left));
			}
		}

		internal static void AddWatchHUD(bool left, RectTransform hudCluster)
		{
			if (HandsReady)
			{
				((left == ModConfig.LeftDominantHand.Value) ? dominantHand : nonDominantHand).watchHud.AddHUDCluster(hudCluster);
			}
			else
			{
				watchHudQueue.Add(new HUDQueueEntry(hudCluster, left));
			}
		}

		public static void AddHandPrefab(GameObject handPrefab)
		{
			if (!Object.op_Implicit((Object)(object)handPrefab))
			{
				throw new ArgumentNullException("VR Mod: Cannot add null as a hand prefab.");
			}
			Hand handComponent = handPrefab.GetComponent<Hand>();
			if (!Object.op_Implicit((Object)(object)handComponent))
			{
				throw new ArgumentException("VR Mod: The prefab is missing a Hand component and cannot be added as a hand prefab.");
			}
			if (handPrefabs.Exists((GameObject x) => CheckPrefabMatch(handComponent, x)))
			{
				throw new ArgumentException("VR Mod: A hand with the same body name and hand type has already been added. Make sure to only add one hand of type 'Both' or one 'Dominant' and 'Non-Dominant' hand for the same body.");
			}
			handPrefabs.Add(handPrefab);
		}

		public static void AddHandSkin(HandSkinDef skinDef)
		{
			List<GameObject> list = handPrefabs.Where(delegate(GameObject x)
			{
				Hand component = x.GetComponent<Hand>();
				return component.bodyName == skinDef.characterBodyName && (skinDef.handType == HandType.Both || skinDef.handType == component.handType);
			}).ToList();
			if (list == null && list.Count <= 0)
			{
				VRMod.StaticLogger.LogError((object)("No hand prefab was found for hand skin " + skinDef.originalSkinNameToken));
				return;
			}
			foreach (GameObject item in list)
			{
				item.GetComponent<Hand>().AddSkin(skinDef);
			}
		}

		public static HandController GetHandByDominance(bool dominant)
		{
			if (!HandsReady)
			{
				VRMod.StaticLogger.LogError((object)"Cannot access the VR hands as they are not instantiated. Returning null.");
				return null;
			}
			if (!dominant)
			{
				return nonDominantHand;
			}
			return dominantHand;
		}

		public static HandController GetHandBySide(bool left)
		{
			if (left != ModConfig.LeftDominantHand.Value)
			{
				return nonDominantHand;
			}
			return dominantHand;
		}

		private static bool CheckPrefabMatch(Hand hand, GameObject prefab)
		{
			Hand component = prefab.GetComponent<Hand>();
			if (hand.bodyName == component.bodyName)
			{
				if (component.handType != HandType.Both && hand.handType != HandType.Both)
				{
					return component.handType == hand.handType;
				}
				return true;
			}
			return false;
		}

		private static void InitHandsAndHUDs(orig_Start orig, CameraRigController self)
		{
			orig.Invoke(self);
			if (!HandsReady)
			{
				SetupHands();
			}
			dominantHand.smallHud.Init(self);
			nonDominantHand.smallHud.Init(self);
			foreach (HUDQueueEntry item in wristHudQueue)
			{
				GetHandBySide(item.left).smallHud.AddHUDCluster(item.transform);
			}
			wristHudQueue.Clear();
			dominantHand.watchHud.Init(self);
			nonDominantHand.watchHud.Init(self);
			foreach (HUDQueueEntry item2 in watchHudQueue)
			{
				GetHandBySide(item2.left).watchHud.AddHUDCluster(item2.transform);
			}
			watchHudQueue.Clear();
		}

		private static void SetupHands()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			HandController component = Object.Instantiate<GameObject>(handControllerPrefab).GetComponent<HandController>();
			component.xrNode = (XRNode)4;
			Vector3 localScale = ((Component)component).transform.localScale;
			localScale.x = 0f - localScale.x;
			((Component)component).transform.localScale = localScale;
			TrackedPoseDriver obj = ((Component)component).gameObject.AddComponent<TrackedPoseDriver>();
			obj.deviceType = (DeviceType)1;
			obj.poseSource = (TrackedPose)4;
			obj.trackingType = (TrackingType)0;
			obj.updateType = (UpdateType)0;
			HandController component2 = Object.Instantiate<GameObject>(handControllerPrefab).GetComponent<HandController>();
			component2.xrNode = (XRNode)5;
			TrackedPoseDriver obj2 = ((Component)component2).gameObject.AddComponent<TrackedPoseDriver>();
			obj2.deviceType = (DeviceType)1;
			obj2.poseSource = (TrackedPose)5;
			obj2.trackingType = (TrackingType)0;
			obj2.updateType = (UpdateType)0;
			dominantHand = (ModConfig.LeftDominantHand.Value ? component : component2);
			nonDominantHand = (ModConfig.LeftDominantHand.Value ? component2 : component);
			dominantHand.SetPrefabs(handPrefabs.Where((GameObject x) => CheckDominance(x, dominant: true)).ToList());
			nonDominantHand.SetPrefabs(handPrefabs.Where((GameObject x) => CheckDominance(x, dominant: false)).ToList());
			dominantHand.oppositeHand = nonDominantHand;
			nonDominantHand.oppositeHand = dominantHand;
		}

		private static bool CheckDominance(GameObject prefab, bool dominant)
		{
			Hand component = prefab.GetComponent<Hand>();
			if (component.handType != HandType.Both)
			{
				return dominant == (component.handType == HandType.Dominant);
			}
			return true;
		}

		internal static void SetHandPair(CharacterBody body)
		{
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			if (!HandsReady)
			{
				SetupHands();
			}
			string currentHand = ((Object)body).name.Substring(0, ((Object)body).name.IndexOf("(Clone)"));
			dominantHand.SetCurrentHand(currentHand);
			nonDominantHand.SetCurrentHand(currentHand);
			body.aimOriginTransform = ((Component)dominantHand.currentHand.currentMuzzle).transform;
			ChildLocator component = ((Component)body.modelLocator.modelTransform).GetComponent<ChildLocator>();
			if (Object.op_Implicit((Object)(object)component))
			{
				List<NameTransformPair> list = component.transformPairs.ToList();
				if (!list.Exists((NameTransformPair x) => x.name == "CurrentDominantMuzzle"))
				{
					list.Add(new NameTransformPair
					{
						name = "CurrentDominantMuzzle",
						transform = ((Component)dominantHand.currentHand.currentMuzzle).transform
					});
					list.Add(new NameTransformPair
					{
						name = "CurrentNonDominantMuzzle",
						transform = ((Component)nonDominantHand.currentHand.currentMuzzle).transform
					});
					component.transformPairs = list.ToArray();
				}
				else
				{
					int num = list.FindIndex((NameTransformPair x) => x.name == "CurrentDominantMuzzle");
					int num2 = list.FindIndex((NameTransformPair x) => x.name == "CurrentNonDominantMuzzle");
					component.transformPairs[num].transform = ((Component)dominantHand.currentHand.currentMuzzle).transform;
					component.transformPairs[num2].transform = ((Component)nonDominantHand.currentHand.currentMuzzle).transform;
				}
				Muzzle[] muzzles = dominantHand.currentHand.muzzles;
				foreach (Muzzle muzzle in muzzles)
				{
					for (int num4 = 0; num4 < component.transformPairs.Length; num4++)
					{
						if (muzzle.entriesToReplaceIfDominant.Contains(component.transformPairs[num4].name))
						{
							component.transformPairs[num4].transform = ((Component)muzzle).transform;
						}
					}
					list = component.transformPairs.ToList();
					string pairName = ((Object)((Component)muzzle).transform).name + "_Dominant";
					if (!list.Exists((NameTransformPair x) => x.name == pairName))
					{
						list.Add(new NameTransformPair
						{
							name = pairName,
							transform = ((Component)muzzle).transform
						});
						component.transformPairs = list.ToArray();
					}
				}
				muzzles = nonDominantHand.currentHand.muzzles;
				foreach (Muzzle muzzle2 in muzzles)
				{
					for (int num5 = 0; num5 < component.transformPairs.Length; num5++)
					{
						if (muzzle2.entriesToReplaceIfNonDominant.Contains(component.transformPairs[num5].name))
						{
							component.transformPairs[num5].transform = ((Component)muzzle2).transform;
						}
					}
					list = component.transformPairs.ToList();
					string pairName2 = ((Object)((Component)muzzle2).transform).name + "_NonDominant";
					if (!list.Exists((NameTransformPair x) => x.name == pairName2))
					{
						list.Add(new NameTransformPair
						{
							name = pairName2,
							transform = ((Component)muzzle2).transform
						});
						component.transformPairs = list.ToArray();
					}
				}
			}
			UpdateForcedAimRay();
			if (onHandPairSet != null)
			{
				onHandPairSet(body);
			}
		}
	}
	public static class ModConfig
	{
		internal class ConfigSetting
		{
			internal enum SettingUpdate
			{
				Instant,
				NextStage,
				AfterRestart
			}

			internal readonly ConfigEntryBase entry;

			internal readonly float minValue;

			internal readonly float maxValue;

			internal SettingUpdate settingUpdate;

			internal ConfigSetting(ConfigEntryBase entry, SettingUpdate settingUpdate, EventHandler onChangedCallback = null)
			{
				this.entry = entry;
				this.settingUpdate = settingUpdate;
				if (onChangedCallback != null)
				{
					AddCallback(onChangedCallback);
				}
			}

			internal ConfigSetting(ConfigEntryBase entry, float minValue, float maxValue, SettingUpdate settingUpdate, EventHandler onChangedCallback = null)
			{
				this.entry = entry;
				this.minValue = minValue;
				this.maxValue = maxValue;
				this.settingUpdate = settingUpdate;
				if (onChangedCallback != null)
				{
					AddCallback(onChangedCallback);
				}
			}

			private void AddCallback(EventHandler callback)
			{
				if (entry.SettingType == typeof(bool))
				{
					(entry as ConfigEntry<bool>).SettingChanged += callback;
				}
				else if (entry.SettingType == typeof(int))
				{
					(entry as ConfigEntry<int>).SettingChanged += callback;
				}
				else if (entry.SettingType == typeof(float))
				{
					(entry as ConfigEntry<float>).SettingChanged += callback;
				}
				else if (entry.SettingType == typeof(string))
				{
					(entry as ConfigEntry<string>).SettingChanged += callback;
				}
			}
		}

		private const string CONFIG_FILE_NAME = "VRMod.cfg";

		private static readonly ConfigFile configFile = new ConfigFile(Path.Combine(Paths.ConfigPath, "VRMod.cfg"), true);

		internal static readonly Dictionary<string, ConfigSetting> settings = new Dictionary<string, ConfigSetting>();

		internal static Color RayColor = Color.white;

		private static bool prevLeftHandedValue;

		internal static ConfigEntry<bool> OculusMode { get; private set; }

		internal static ConfigEntry<bool> FirstPerson { get; private set; }

		internal static ConfigEntry<bool> UseConfortVignette { get; private set; }

		internal static ConfigEntry<bool> SeatedMode { get; private set; }

		internal static ConfigEntry<float> HeightMultiplier { get; private set; }

		internal static ConfigEntry<float> ControllerAngleOffset { get; private set; }

		internal static ConfigEntry<float> IntroCameraYaw { get; private set; }

		internal static ConfigEntry<bool> AutoSprint { get; private set; }

		internal static ConfigEntry<string> HapticsSuit { get; private set; }

		internal static ConfigEntry<string> RayColorHex { get; private set; }

		internal static ConfigEntry<float> RayOpacity { get; private set; }

		internal static ConfigEntry<bool> CommandoDualWield { get; private set; }

		internal static ConfigEntry<float> BanditWeaponGripSnapAngle { get; private set; }

		internal static ConfigEntry<float> MercSwingSpeedThreshold { get; private set; }

		internal static ConfigEntry<float> LoaderSwingSpeedThreshold { get; private set; }

		internal static ConfigEntry<float> AcridSwingSpeedThreshold { get; private set; }

		internal static ConfigEntry<float> RailgunnerWeaponGripSnapAngle { get; private set; }

		internal static ConfigEntry<float> RailgunnerZoomMultiplier { get; private set; }

		internal static ConfigEntry<bool> RailgunnerDisableScopeRay { get; private set; }

		internal static ConfigEntry<bool> WristHUD { get; private set; }

		internal static ConfigEntry<bool> WatchHUD { get; private set; }

		internal static ConfigEntry<bool> BetterHealthBar { get; private set; }

		internal static ConfigEntry<bool> UseSmoothHUD { get; private set; }

		internal static ConfigEntry<int> HUDWidth { get; private set; }

		internal static ConfigEntry<int> HUDHeight { get; private set; }

		internal static ConfigEntry<float> BottomAnchor { get; private set; }

		internal static ConfigEntry<float> TopAnchor { get; private set; }

		internal static ConfigEntry<float> LeftAnchor { get; private set; }

		internal static ConfigEntry<float> RightAnchor { get; private set; }

		internal static ConfigEntry<bool> LIVHUD { get; private set; }

		internal static Vector2 AnchorMin { get; private set; }

		internal static Vector2 AnchorMax { get; private set; }

		internal static ConfigEntry<bool> SnapTurn { get; private set; }

		internal static ConfigEntry<int> SnapTurnAngle { get; private set; }

		internal static ConfigEntry<float> SnapTurnHoldDelay { get; private set; }

		internal static ConfigEntry<bool> LockedCameraPitch { get; private set; }

		internal static ConfigEntry<bool> UseMotionControls { get; private set; }

		internal static ConfigEntry<bool> LeftDominantHand { get; private set; }

		internal static ConfigEntry<bool> ControllerMovementDirection { get; private set; }

		internal static ConfigEntry<float> AimStabiliserAmount { get; private set; }

		internal static bool InitialOculusModeValue { get; private set; }

		internal static bool InitialFirstPersonValue { get; private set; }

		internal static bool InitialRoomscaleValue { get; private set; }

		internal static bool InitialMotionControlsValue { get; private set; }

		internal static bool TempWristHUDValue { get; private set; }

		internal static bool TempWatchHUDValue { get; private set; }

		internal static bool TempLockedCameraPitchValue { get; private set; }

		public static bool MotionControlsEnabled => InitialMotionControlsValue;

		public static bool LeftHanded => LeftDominantHand.Value;

		internal static ConfigEntry<bool> HighlightChests { get; private set; }

		internal static ConfigEntry<bool> ItemHints { get; private set; }

		internal static ConfigEntry<bool> RuntimeHands { get; private set; }

		internal static ConfigEntry<bool> RuntimeHandsDebug { get; private set; }

		internal static ConfigEntry<bool> RuntimeHandsRay { get; private set; }

		internal static ConfigEntry<bool> RuntimeHandsForearm { get; private set; }

		internal static ConfigEntry<float> RuntimeHandsItemScale { get; private set; }

		internal static ConfigEntry<float> IntroSeatedHeightOffset { get; private set; }

		internal static ConfigEntry<bool> ShowUnfocusedWarning { get; private set; }

		internal static ConfigEntry<float> ReportTextZoom { get; private set; }

		internal static ConfigEntry<float> ReportWidthMeters { get; private set; }

		internal static ConfigEntry<float> SeekerLotusRaise { get; private set; }

		internal static ConfigEntry<float> SeekerMeditateRaise { get; private set; }

		internal static ConfigEntry<T> BindRuntimeHand<T>(string bodyName, string key, T defaultValue, string description)
		{
			return configFile.Bind<T>("RuntimeHands (experimental)", bodyName + "_" + key, defaultValue, description);
		}

		internal static void ReloadRuntimeHandConfig()
		{
			try
			{
				configFile.Reload();
			}
			catch
			{
			}
		}

		internal static void Init()
		{
			//IL_0437: Unknown result type (might be due to invalid IL or missing references)
			//IL_043c: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_064c: Unknown result type (might be due to invalid IL or missing references)
			OculusMode = configFile.Bind<bool>("VR Settings", "Use Oculus mode", false, "OBSOLETE - leave this off. It is a leftover from the SteamVR version of the mod. This build runs on OpenXR and simply uses whichever OpenXR runtime Windows has set as active (SteamVR, Oculus/Meta, VDXR or WMR), so there is nothing for it to switch. Choose your headset by setting that runtime active in its own software instead.");
			FirstPerson = configFile.Bind<bool>("VR Settings", "First Person", true, "Experience the game in a first person POV.");
			UseConfortVignette = configFile.Bind<bool>("VR Settings", "Confort Vignette", true, "Adds a black vignette during high-mobility abilities to reduce motion sickness.");
			SeatedMode = configFile.Bind<bool>("VR Settings", "Seated Mode", true, "Enable this setting for a better seated experience. Recentering your HMD will place the camera at eye level of the in-game character. Disable it for standing/roomscale play where your real floor height sets the camera height. Keep in mind that seated play is not compatible with LIV XR Capture.");
			HeightMultiplier = configFile.Bind<float>("VR Settings", "Character height multiplier", 1f, "Used for scaling the view. This multiplier will be applied to the character's height. Increase this value to feel taller or decrease it to feel smaller.");
			ControllerAngleOffset = configFile.Bind<float>("VR Settings", "Controller aim pitch v2", 75f, "Pitch (in degrees) applied to the VR hands/aim to compensate for the difference between the OpenXR grip pose and how the hand models were authored. Lower values aim higher, higher values aim lower (90 aims straight along the grip; 75 tilts the aim up ~15 degrees). Applies on the next stage.");
			IntroCameraYaw = configFile.Bind<float>("VR Settings", "Intro camera yaw", 180f, "Extra yaw (in degrees) applied to the camera during the opening spaceship cutscene. 180 faces the incoming ship; set to 0 for the old orientation, or nudge it if the ship isn't centered.");
			AutoSprint = configFile.Bind<bool>("VR Settings", "Auto Sprint", false, "Sprint automatically whenever you push the left stick, so you never have to click it in. Abilities that normally interrupt sprinting still do.");
			HighlightChests = configFile.Bind<bool>("VR Settings", "Highlight chests", false, "Highlights purchasable interactables (chests, drones, shrines, etc.) with a coloured outline so they are easier to spot in VR.");
			ItemHints = configFile.Bind<bool>("VR Settings", "Item hints", false, "Shows the full item description (stat details from the logbook) in pickup notifications and item tooltips instead of the short flavour text. Pinging a dropped item also prints its description in chat.");
			HapticsSuit = configFile.Bind<string>("VR Settings", "Haptics Suit", "None", "The type of haptics suit you're wearing. The mod currently supports the Shockwave suit. The bHaptics suit may also come in the future.");
			RayColorHex = configFile.Bind<string>("Survivor Settings", "General: Aim ray color", "FFFFFF", "Changes the color of aim rays.");
			RayOpacity = configFile.Bind<float>("Survivor Settings", "General: Aim ray opacity", 0.6f, "Sets the aim ray opacity between 0 (invisible) and 1 (opaque).");
			CommandoDualWield = configFile.Bind<bool>("Survivor Settings", "Commando: Dual wield", true, "TRUE: Double Tap and Phase Blast alternate between the left and right pistol for each bullet. FALSE: Double Tap only uses the dominant pistol while Phase Blast uses the non-dominant pistol.");
			BanditWeaponGripSnapAngle = configFile.Bind<float>("Survivor Settings", "Bandit: Weapon grip snap angle", 40f, "Angle in which the non-dominant hand can grip the weapon. Set to 0 to completely disable two-handed gripping. Set to 180 for constant grip.");
			MercSwingSpeedThreshold = configFile.Bind<float>("Survivor Settings", "Mercenary: Swing speed threshold", 20f, "The sword tip speed required to trigger an attack.");
			LoaderSwingSpeedThreshold = configFile.Bind<float>("Survivor Settings", "Loader: Swing speed threshold", 12f, "The mech fist speed required to trigger an attack.");
			AcridSwingSpeedThreshold = configFile.Bind<float>("Survivor Settings", "Acrid: Swing speed threshold", 10f, "The claw tip speed required to trigger an attack.");
			RailgunnerWeaponGripSnapAngle = configFile.Bind<float>("Survivor Settings", "Railgunner: Weapon grip snap angle", 50f, "Angle in which the non-dominant hand can grip the weapon. Set to 0 to completely disable two-handed gripping. Set to 180 for constant grip.");
			RailgunnerZoomMultiplier = configFile.Bind<float>("Survivor Settings", "Railgunner: Zoom multiplier", 3f, "Changes the zoom multiplier of the scope.");
			RailgunnerDisableScopeRay = configFile.Bind<bool>("Survivor Settings", "Railgunner: Hide ray while scoping", false, "Disables the aim ray while using the scope. Enable this setting if you find it obstructs the scope too much... or if you're a gamer and think no scopes should be harder.");
			RuntimeHands = configFile.Bind<bool>("RuntimeHands (experimental)", "Enable runtime hands", true, "EXPERIMENTAL: for characters without an authored VR hand (e.g. Seekers of the Storm survivors), build a hand model at runtime from the character's own arm mesh. Characters with real VR hands are unaffected.");
			RuntimeHandsDebug = configFile.Bind<bool>("RuntimeHands (experimental)", "Debug mode", false, "Draws RGB axis lines on runtime hands (blue = aim direction), logs every entity state the local character enters, and re-reads this config file every 3 seconds so the per-character offsets below can be tuned live while in game.");
			RuntimeHandsRay = configFile.Bind<bool>("RuntimeHands (experimental)", "Show aim ray", true, "Shows the aim ray on runtime hands so aiming is usable before the offsets are tuned.");
			RuntimeHandsForearm = configFile.Bind<bool>("RuntimeHands (experimental)", "Include forearm", true, "Also bakes the forearm into the runtime hand mesh (rigid - it will not bend at the elbow).");
			RuntimeHandsItemScale = configFile.Bind<float>("RuntimeHands (experimental)", "Item display scale on hands", 1f, "Scales item pickups that the game attaches to the runtime VR hands and forearms (razor wire, etc.). They are modelled for the third-person character, so at 1.0 they fill the view in first person. 0.5 is half size; 1.0 is the game's own size.");
			IntroSeatedHeightOffset = configFile.Bind<float>("Camera", "Intro cutscene seated height (metres)", 1.45f, "Seated mode only. How much higher (in metres, as if you stood up that much) the view sits during the opening cutscene. 0 = head exactly at the cutscene camera position, which is too low for most seated players.");
			ShowUnfocusedWarning = configFile.Bind<bool>("HUD", "Show unfocused warning", true, "Shows a small warning in the headset when the game window on the monitor is not the focused window (keyboard/mouse input then goes elsewhere). It appears after the window has been unfocused for a couple of seconds.");
			ReportTextZoom = configFile.Bind<float>("HUD", "End-of-run report text size", 4f, "How much larger the text and icons on the end-of-run stats report are drawn relative to its panels (1 = the flat-screen layout). Higher values make the print bigger and the panels denser. 1 to 4.");
			ReportWidthMeters = configFile.Bind<float>("HUD", "End-of-run report width", 6f, "Overall width of the end-of-run stats report in metres (it sits 15 m in front of you). Smaller = the whole screen fits in view without turning your head; larger = bigger but you have to look left and right. 4 to 24.");
			SeekerLotusRaise = configFile.Bind<float>("HUD", "Seeker lotus height", 210f, "How far above the health bar the Seeker's lotus petals are drawn (HUD units). Higher = further up. Applies next time the Seeker spawns.");
			SeekerMeditateRaise = configFile.Bind<float>("HUD", "Seeker meditation height", 100f, "How far the Seeker meditation mini-game (arch + arrow inputs) is raised from where the game puts it (HUD units). Higher = further up. Applies next time you start meditating.");
			global::VRMod.RuntimeHands.PreRegisterKnownBodies();
			RayColor = HexToColor(RayColorHex.Value);
			WristHUD = configFile.Bind<bool>("HUD Settings", "Wrist HUD", true, "TRUE: Attaches the healthbar, money and cooldowns to the wrists. FALSE: Attaches the healthbar, money and cooldowns to the camera.");
			WatchHUD = configFile.Bind<bool>("HUD Settings", "Watch HUD", true, "TRUE: Attaches the inventory, chat, objective and allies to a watch that appears when looking at it. FALSE: Attaches the inventory, chat, objective and allies to the camera.");
			BetterHealthBar = configFile.Bind<bool>("HUD Settings", "Camera Health Bar", true, "TRUE: Makes the health bar more visible by placing it on the bottom-middle of the camera HUD. FALSE: Places the healthbar on the left wrist HUD (if the wrist HUD setting is enabled).");
			UseSmoothHUD = configFile.Bind<bool>("HUD Settings", "Smooth HUD", true, "TRUE: The camera HUD will follow the camera smoothly making it lag behind when moving the headset. FALSE: The camera HUD will follow the camera directly without smoothing.");
			HUDWidth = configFile.Bind<int>("HUD Settings", "HUD Width", 1200, "Width of the camera HUD.");
			HUDHeight = configFile.Bind<int>("HUD Settings", "HUD Height", 1000, "Height of the camera HUD.");
			BottomAnchor = configFile.Bind<float>("HUD Settings", "Bottom anchor", 1f, "Position of the bottom HUD anchor between 0 and 1 (Middle to bottom edge of the screen).");
			TopAnchor = configFile.Bind<float>("HUD Settings", "Top anchor", 0.7f, "Position of the top HUD anchor between 0 and 1 (Middle to top edge of the screen).");
			LeftAnchor = configFile.Bind<float>("HUD Settings", "Left anchor", 1f, "Position of the left HUD anchor between 0 and 1 (Middle to left edge of the screen).");
			RightAnchor = configFile.Bind<float>("HUD Settings", "Right anchor", 1f, "Position of the right HUD anchor between 0 and 1 (Middle to right edge of the screen).");
			LIVHUD = configFile.Bind<bool>("HUD Settings", "Display HUD on LIV camera", true, "The classic RoR2 HUD will display on the LIV camera when using the LIV XR capture. Since the camera cannot render any UI, this is a good way for viewers to see the HUD.");
			AnchorMin = new Vector2((1f - Mathf.Clamp(LeftAnchor.Value, 0f, 1f)) / 2f, (1f - Mathf.Clamp(BottomAnchor.Value, 0f, 1f)) / 2f);
			AnchorMax = new Vector2((1f + Mathf.Clamp(RightAnchor.Value, 0f, 1f)) / 2f, (1f + Mathf.Clamp(TopAnchor.Value, 0f, 1f)) / 2f);
			SnapTurn = configFile.Bind<bool>("Controls", "Snap turn", true, "TRUE: Rotate the camera in increments (unavailable in third person).  FALSE: Smooth camera rotation.");
			SnapTurnAngle = configFile.Bind<int>("Controls", "Snap turn angle", 45, "Rotation in degrees of each snap turn. If you're trying to change the smooth turn speed, use the gamepad sensitivity setting in-game.");
			SnapTurnHoldDelay = configFile.Bind<float>("Controls", "Snap turn hold delay", 0.33f, "Time in seconds between each snap turn when holding a direction.");
			LockedCameraPitch = configFile.Bind<bool>("Controls", "Locked camera pitch", true, "Prevents the camera from rotating vertically (cannot disable when snap turn is on).");
			UseMotionControls = configFile.Bind<bool>("Controls", "Use motion controls", true, "Enables motion controls for VR controllers. They act as a simple gamepad when set to false.");
			LeftDominantHand = configFile.Bind<bool>("Controls", "Set left hand as dominant", false, "Swaps left/right triggers and grips. The aiming hand for each skill is also swapped as well as hand models.");
			ControllerMovementDirection = configFile.Bind<bool>("Controls", "Use controller direction for movement", false, "When enabled, pushing forward on the joystick will move the character towards the direction the controller is pointing instead of the head.");
			AimStabiliserAmount = configFile.Bind<float>("Controls", "Aim stabiliser amount", 0.5f, "The amount of smoothing applied to the hand position and rotation. Set to 0 to completely remove stabilisation.");
			UpdateDependantValues();
			prevLeftHandedValue = LeftDominantHand.Value;
			InitialFirstPersonValue = FirstPerson.Value;
			InitialMotionControlsValue = InitialFirstPersonValue && UseMotionControls.Value;
			InitialOculusModeValue = OculusMode.Value;
			InitialRoomscaleValue = !SeatedMode.Value;
			TempWristHUDValue = InitialMotionControlsValue && WristHUD.Value;
			TempWatchHUDValue = InitialMotionControlsValue && WatchHUD.Value;
			TempLockedCameraPitchValue = SnapTurn.Value || InitialMotionControlsValue || LockedCameraPitch.Value;
			settings.Add("vr_auto_sprint", new ConfigSetting((ConfigEntryBase)(object)AutoSprint, ConfigSetting.SettingUpdate.Instant));
			settings.Add("vr_highlight_chests", new ConfigSetting((ConfigEntryBase)(object)HighlightChests, ConfigSetting.SettingUpdate.Instant, ChestHighlighter.OnSettingChanged));
			settings.Add("vr_item_hints", new ConfigSetting((ConfigEntryBase)(object)ItemHints, ConfigSetting.SettingUpdate.Instant));
			settings.Add("vr_snap_turn", new ConfigSetting((ConfigEntryBase)(object)SnapTurn, ConfigSetting.SettingUpdate.Instant));
			settings.Add("vr_snap_angle", new ConfigSetting((ConfigEntryBase)(object)SnapTurnAngle, 30f, 180f, ConfigSetting.SettingUpdate.Instant));
			settings.Add("vr_snap_delay", new ConfigSetting((ConfigEntryBase)(object)SnapTurnHoldDelay, 0.2f, 1f, ConfigSetting.SettingUpdate.Instant));
			settings.Add("vr_controller_movement", new ConfigSetting((ConfigEntryBase)(object)ControllerMovementDirection, ConfigSetting.SettingUpdate.Instant));
			settings.Add("vr_vignette", new ConfigSetting((ConfigEntryBase)(object)UseConfortVignette, ConfigSetting.SettingUpdate.Instant, ChangeVignetteSetting));
			settings.Add("vr_left_handed", new ConfigSetting((ConfigEntryBase)(object)LeftDominantHand, ConfigSetting.SettingUpdate.Instant, ChangeHandDominance));
			settings.Add("vr_aim_stabiliser_amount", new ConfigSetting((ConfigEntryBase)(object)AimStabiliserAmount, 0f, 1f, ConfigSetting.SettingUpdate.Instant));
			settings.Add("vr_wrist_hud", new ConfigSetting((ConfigEntryBase)(object)WristHUD, ConfigSetting.SettingUpdate.NextStage));
			settings.Add("vr_watch_hud", new ConfigSetting((ConfigEntryBase)(object)WatchHUD, ConfigSetting.SettingUpdate.NextStage));
			settings.Add("vr_better_health", new ConfigSetting((ConfigEntryBase)(object)BetterHealthBar, ConfigSetting.SettingUpdate.NextStage));
			settings.Add("vr_smooth_hud", new ConfigSetting((ConfigEntryBase)(object)UseSmoothHUD, ConfigSetting.SettingUpdate.Instant, ChangeSmoothHUD));
			settings.Add("vr_liv_hud", new ConfigSetting((ConfigEntryBase)(object)LIVHUD, ConfigSetting.SettingUpdate.Instant, ChangeLIVHUD));
			settings.Add("vr_seated", new ConfigSetting((ConfigEntryBase)(object)SeatedMode, ConfigSetting.SettingUpdate.AfterRestart));
			settings.Add("vr_height", new ConfigSetting((ConfigEntryBase)(object)HeightMultiplier, 0.5f, 2f, ConfigSetting.SettingUpdate.NextStage));
			settings.Add("vr_controller_angle", new ConfigSetting((ConfigEntryBase)(object)ControllerAngleOffset, -90f, 90f, ConfigSetting.SettingUpdate.NextStage));
			settings.Add("vr_ray_color", new ConfigSetting((ConfigEntryBase)(object)RayColorHex, ConfigSetting.SettingUpdate.Instant, ChangeRayColor));
			settings.Add("vr_ray_opacity", new ConfigSetting((ConfigEntryBase)(object)RayOpacity, 0f, 1f, ConfigSetting.SettingUpdate.Instant, ChangeRayColor));
			settings.Add("vr_com_dual", new ConfigSetting((ConfigEntryBase)(object)CommandoDualWield, ConfigSetting.SettingUpdate.Instant));
			settings.Add("vr_bandit_angle", new ConfigSetting((ConfigEntryBase)(object)BanditWeaponGripSnapAngle, 0f, 180f, ConfigSetting.SettingUpdate.Instant, MotionControls.UpdateBanditSnapAngle));
			settings.Add("vr_merc_threshold", new ConfigSetting((ConfigEntryBase)(object)MercSwingSpeedThreshold, 5f, 50f, ConfigSetting.SettingUpdate.Instant, MotionControls.UpdateMercMeleeThreshold));
			settings.Add("vr_loader_threshold", new ConfigSetting((ConfigEntryBase)(object)LoaderSwingSpeedThreshold, 5f, 50f, ConfigSetting.SettingUpdate.Instant, MotionControls.UpdateLoaderMeleeThreshold));
			settings.Add("vr_acrid_threshold", new ConfigSetting((ConfigEntryBase)(object)AcridSwingSpeedThreshold, 5f, 50f, ConfigSetting.SettingUpdate.Instant, MotionControls.UpdateAcridMeleeThreshold));
			settings.Add("vr_railgunner_angle", new ConfigSetting((ConfigEntryBase)(object)RailgunnerWeaponGripSnapAngle, 0f, 180f, ConfigSetting.SettingUpdate.Instant, MotionControls.UpdateRailgunnerSnapAngle));
			settings.Add("vr_railgunner_zoom", new ConfigSetting((ConfigEntryBase)(object)RailgunnerZoomMultiplier, 2f, 4f, ConfigSetting.SettingUpdate.Instant));
			settings.Add("vr_railgunner_scoperay", new ConfigSetting((ConfigEntryBase)(object)RailgunnerDisableScopeRay, ConfigSetting.SettingUpdate.Instant));
			settings.Add("vr_hud_width", new ConfigSetting((ConfigEntryBase)(object)HUDWidth, 400f, 2400f, ConfigSetting.SettingUpdate.Instant, ChangeHUDSize));
			settings.Add("vr_hud_height", new ConfigSetting((ConfigEntryBase)(object)HUDHeight, 400f, 2400f, ConfigSetting.SettingUpdate.Instant, ChangeHUDSize));
			settings.Add("vr_anchor_bottom", new ConfigSetting((ConfigEntryBase)(object)BottomAnchor, 0f, 1f, ConfigSetting.SettingUpdate.Instant, ChangeHUDAnchors));
			settings.Add("vr_anchor_top", new ConfigSetting((ConfigEntryBase)(object)TopAnchor, 0f, 1f, ConfigSetting.SettingUpdate.Instant, ChangeHUDAnchors));
			settings.Add("vr_anchor_left", new ConfigSetting((ConfigEntryBase)(object)LeftAnchor, 0f, 1f, ConfigSetting.SettingUpdate.Instant, ChangeHUDAnchors));
			settings.Add("vr_anchor_right", new ConfigSetting((ConfigEntryBase)(object)RightAnchor, 0f, 1f, ConfigSetting.SettingUpdate.Instant, ChangeHUDAnchors));
			settings.Add("vr_oculus", new ConfigSetting((ConfigEntryBase)(object)OculusMode, ConfigSetting.SettingUpdate.AfterRestart));
			settings.Add("vr_first_person", new ConfigSetting((ConfigEntryBase)(object)FirstPerson, ConfigSetting.SettingUpdate.AfterRestart));
			settings.Add("vr_locked_camera", new ConfigSetting((ConfigEntryBase)(object)LockedCameraPitch, ConfigSetting.SettingUpdate.Instant));
			settings.Add("vr_motion_controls", new ConfigSetting((ConfigEntryBase)(object)UseMotionControls, ConfigSetting.SettingUpdate.AfterRestart));
			settings.Add("vr_haptics_suit", new ConfigSetting((ConfigEntryBase)(object)HapticsSuit, ConfigSetting.SettingUpdate.AfterRestart));
		}

		private static void ChangeLIVHUD(object sender, EventArgs e)
		{
			if ((Object)(object)UIFixes.livHUD != (Object)null)
			{
				((Component)UIFixes.livHUD).gameObject.SetActive(LIVHUD.Value);
			}
			else if (LIVHUD.Value && Object.op_Implicit((Object)(object)CameraFixes.liv) && ((Behaviour)CameraFixes.liv).enabled)
			{
				UIFixes.CreateLIVHUD(CameraFixes.liv.render.cameraInstance);
			}
		}

		private static void ChangeHandDominance(object sender, EventArgs e)
		{
			if (LeftDominantHand.Value != prevLeftHandedValue)
			{
				prevLeftHandedValue = LeftDominantHand.Value;
				Controllers.ChangeDominanceDependantMaps();
				MotionControls.UpdateDominance();
			}
		}

		private static void ChangeHUDAnchors(object sender, EventArgs e)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: 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)
			AnchorMin = new Vector2((1f - Mathf.Clamp(LeftAnchor.Value, 0f, 1f)) / 2f, (1f - Mathf.Clamp(BottomAnchor.Value, 0f, 1f)) / 2f);
			AnchorMax = new Vector2((1f + Mathf.Clamp(RightAnchor.Value, 0f, 1f)) / 2f, (1f + Mathf.Clamp(TopAnchor.Value, 0f, 1f)) / 2f);
			if (Object.op_Implicit((Object)(object)Run.instance))
			{
				CameraRigController cameraRigController = LocalUserManager.GetFirstLocalUser().cameraRigController;
				if (Object.op_Implicit((Object)(object)cameraRigController) && Object.op_Implicit((Object)(object)cameraRigController.hud))
				{
					HUD hud = cameraRigController.hud;
					Transform obj = hud.mainUIPanel.transform.Find("SpringCanvas");
					Transform obj2 = ((obj is RectTransform) ? obj : null);
					((RectTransform)obj2).anchorMin = AnchorMin;
					((RectTransform)obj2).anchorMax = AnchorMax;
					Transform obj3 = hud.mainContainer.transform.Find("NotificationArea");
					Transform obj4 = ((obj3 is RectTransform) ? obj3 : null);
					((RectTransform)obj4).anchorMin = new Vector2(0.5f, AnchorMin.y);
					((RectTransform)obj4).anchorMax = new Vector2(0.5f, AnchorMin.y);
					Transform obj5 = hud.mainContainer.transform.Find("MapNameCluster");
					Transform obj6 = ((obj5 is RectTransform) ? obj5 : null);
					((RectTransform)obj6).anchorMin = new Vector2(0.5f, (AnchorMax.y - 0.5f) * 0.54f + 0.5f);
					((RectTransform)obj6).anchorMax = new Vector2(0.5f, (AnchorMax.y - 0.5f) * 0.54f + 0.5f);
				}
			}
		}

		private static void ChangeHUDSize(object sender, EventArgs e)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)Run.instance))
			{
				CameraRigController cameraRigController = LocalUserManager.GetFirstLocalUser().cameraRigController;
				if (Object.op_Implicit((Object)(object)cameraRigController) && Object.op_Implicit((Object)(object)cameraRigController.hud))
				{
					Transform transform = ((Component)cameraRigController.hud).transform;
					((RectTransform)((transform is RectTransform) ? transform : null)).sizeDelta = new Vector2((float)HUDWidth.Value, (float)HUDHeight.Value);
				}
			}
		}

		private static void ChangeSmoothHUD(object sender, EventArgs e)
		{
			CameraRigController localCameraRig = Utils.localCameraRig;
			if (Object.op_Implicit((Object)(object)localCameraRig) && Object.op_Implicit((Object)(object)localCameraRig.hud))
			{
				SmoothHUD component = ((Component)localCameraRig.hud).GetComponent<SmoothHUD>();
				if (Object.op_Implicit((Object)(object)component))
				{
					((Behaviour)component).enabled = UseSmoothHUD.Value;
				}
				else if (Object.op_Implicit((Object)(object)Run.instance) && UseSmoothHUD.Value)
				{
					((Component)localCameraRig.hud).gameObject.AddComponent<SmoothHUD>().Init(((Component)localCameraRig.uiCam).transform);
				}
			}
		}

		private static void ChangeRayColor(object sender, EventArgs e)
		{
			//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)
			RayColor = HexToColor(RayColorHex.Value);
			if (MotionControls.HandsReady)
			{
				MotionControls.UpdateRayColor();
			}
		}

		private static void ChangeVignetteSetting(object sender, EventArgs e)
		{
			if (Object.op_Implicit((Object)(object)ConfortVignette.instance))
			{
				((Behaviour)ConfortVignette.instance).enabled = UseConfortVignette.Value;
			}
			else if (Object.op_Implicit((Object)(object)Run.instance) && UseConfortVignette.Value)
			{
				CameraRigController cameraRigController = LocalUserManager.GetFirstLocalUser().cameraRigController;
				if (Object.op_Implicit((Object)(object)cameraRigController))
				{
					((Component)cameraRigController.uiCam).gameObject.AddComponent<ConfortVignette>();
				}
			}
		}

		private static Color HexToColor(string hexString)
		{
			//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_00d7: Unknown result type (might be due to invalid IL or missing references)
			Color white = Color.white;
			white.a = RayOpacity.Value;
			if (hexString.StartsWith("#") && hexString.Length > 1)
			{
				hexString = hexString.Substring(1);
			}
			if (hexString.Length == 6)
			{
				string[] array = new string[3]
				{
					hexString.Substring(0, 2),
					hexString.Substring(2, 2),
					hexString.Substring(4, 2)
				};
				for (int i = 0; i < 3; i++)
				{
					int result = 255;
					if (int.TryParse(array[i], NumberStyles.HexNumber, CultureInfo.InvariantCulture, out result))
					{
						switch (i)
						{
						case 0:
							white.r = (float)result / 255f;
							break;
						case 1:
							white.g = (float)result / 255f;
							break;
						case 2:
							white.b = (float)result / 255f;
							break;
						}
					}
				}
			}
			return white;
		}

		private static void UpdateDependantValues()
		{
			TempLockedCameraPitchValue = SnapTurn.Value || InitialMotionControlsValue || LockedCameraPitch.Value;
			if (InitialMotionControlsValue)
			{
				TempWristHUDValue = WristHUD.Value;
				TempWatchHUDValue = WatchHUD.Value;
			}
		}

		internal static void Save()
		{
			UpdateDependantValues();
			configFile.Save();
		}
	}
	internal static class SettingsAddon
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__SaveOnClose;

			public static hook_GetCurrentValue <1>__GetVRSettingValue;

			public static hook_SubmitSettingInternal <2>__SubmitConfig;

			public static hook_Awake <3>__StopError;

			public static hook_OnSelect <4>__ScrollToButton;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_OnEnter <>9__0_0;

			public static hook_OnExit <>9__0_1;

			public static hook_OpenSettingsMenu <>9__0_2;

			public static Func<Instruction, bool> <>9__5_0;

			public static Action <>9__5_1;

			public static Predicate<Header> <>9__9_0;

			public static Converter<Header, string> <>9__9_1;

			internal void <Init>b__0_0(orig_OnEnter orig, SubmenuMainMenuScreen self, MainMenuController controller)
			{
				orig.Invoke(self, controller);
				if (LooksLikeSettingsPanel(self.submenuPanelInstance))
				{
					SetupVRSettings(self.submenuPanelInstance);
				}
				else if (Object.op_Implicit((Object)(object)self.submenuPanelInstance))
				{
					VRMod.StaticLogger.LogInfo((object)("[VR settings] Main-menu submenu '" + ((Object)self.submenuPanelInstance).name + "' (prefab '" + (Object.op_Implicit((Object)(object)self.submenuPanelPrefab) ? ((Object)self.submenuPanelPrefab).name : "null") + "') is not the settings panel; VR tab not added here."));
				}
			}

			internal void <Init>b__0_1(orig_OnExit orig, SubmenuMainMenuScreen self, MainMenuController controller)
			{
				orig.Invoke(self, controller);
				SaveSettings();
			}

			internal void <Init>b__0_2(orig_OpenSettingsMenu orig, PauseScreenController self)
			{
				orig.Invoke(self);
				VRMod.StaticLogger.LogInfo((object)"[VR settings] In-run pause settings opened; building VR tab.");
				SetupVRSettings(self.submenuObject);
			}

			internal bool <SaveOnClose>b__5_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallvirt<GameObject>(x, "SetActive");
			}

			internal void <SaveOnClose>b__5_1()
			{
				SaveSettings();
			}

			internal bool <SetupVRSettingsInternal>b__9_0(Header h)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return h.headerName == "VR";
			}

			internal string <SetupVRSettingsInternal>b__9_1(Header h)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return h.headerName;
			}
		}

		internal static void Init()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//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_0043: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Expected O, but got Unknown
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			object obj = <>c.<>9__0_0;
			if (obj == null)
			{
				hook_OnEnter val = delegate(orig_OnEnter orig, SubmenuMainMenuScreen self, MainMenuController controller)
				{
					orig.Invoke(self, controller);
					if (LooksLikeSettingsPanel(self.submenuPanelInstance))
					{
						SetupVRSettings(self.submenuPanelInstance);
					}
					else if (Object.op_Implicit((Object)(object)self.submenuPanelInstance))
					{
						VRMod.StaticLogger.LogInfo((object)("[VR settings] Main-menu submenu '" + ((Object)self.submenuPanelInstance).name + "' (prefab '" + (Object.op_Implicit((Object)(object)self.submenuPanelPrefab) ? ((Object)self.submenuPanelPrefab).name : "null") + "') is not the settings panel; VR tab not added here."));
					}
				};
				<>c.<>9__0_0 = val;
				obj = (object)val;
			}
			SubmenuMainMenuScreen.OnEnter += (hook_OnEnter)obj;
			object obj2 = <>c.<>9__0_1;
			if (obj2 == null)
			{
				hook_OnExit val2 = delegate(orig_OnExit orig, SubmenuMainMenuScreen self, MainMenuController controller)
				{
					orig.Invoke(self, controller);
					SaveSettings();
				};
				<>c.<>9__0_1 = val2;
				obj2 = (object)val2;
			}
			SubmenuMainMenuScreen.OnExit += (hook_OnExit)obj2;
			object obj3 = <>c.<>9__0_2;
			if (obj3 == null)
			{
				hook_OpenSettingsMenu val3 = delegate(orig_OpenSettingsMenu orig, PauseScreenController self)
				{
					orig.Invoke(self);
					VRMod.StaticLogger.LogInfo((object)"[VR settings] In-run pause settings opened; building VR tab.");
					SetupVRSettings(self.submenuObject);
				};
				<>c.<>9__0_2 = val3;
				obj3 = (object)val3;
			}
			PauseScreenController.OpenSettingsMenu += (hook_OpenSettingsMenu)obj3;
			object obj4 = <>O.<0>__SaveOnClose;
			if (obj4 == null)
			{
				Manipulator val4 = SaveOnClose;
				<>O.<0>__SaveOnClose = val4;
				obj4 = (object)val4;
			}
			PauseScreenController.Update += (Manipulator)obj4;
			object obj5 = <>O.<1>__GetVRSettingValue;
			if (obj5 == null)
			{
				hook_GetCurrentValue val5 = GetVRSettingValue;
				<>O.<1>__GetVRSettingValue = val5;
				obj5 = (object)val5;
			}
			BaseSettingsControl.GetCurrentValue += (hook_GetCurrentValue)obj5;
			object obj6 = <>O.<2>__SubmitConfig;
			if (obj6 == null)
			{
				hook_SubmitSettingInternal val6 = SubmitConfig;
				<>O.<2>__SubmitConfig = val6;
				obj6 = (object)val6;
			}
			BaseSettingsControl.SubmitSettingInternal += (hook_SubmitSettingInternal)obj6;
			object obj7 = <>O.<3>__StopError;
			if (obj7 == null)
			{
				hook_Awake val7 = StopError;
				<>O.<3>__StopError = val7;
				obj7 = (object)val7;
			}
			BaseSettingsControl.Awake += (hook_Awake)obj7;
			object obj8 = <>O.<4>__ScrollToButton;
			if (obj8 == null)
			{
				hook_OnSelect val8 = ScrollToButton;
				<>O.<4>__ScrollToButton = val8;
				obj8 = (object)val8;
			}
			HGButton.OnSelect += (hook_OnSelect)obj8;
		}

		private static void ScrollToButton(orig_OnSelect orig, HGButton self, BaseEventData eventData)
		{
			orig.Invoke(self, eventData);
			if (((Object)((Component)self).gameObject).name.Contains("VRModSetting"))
			{
				((Component)self).GetComponentInParent<HGScrollRectHelper>().ScrollToShowMe((MPButton)(object)self);
			}
		}

		private static void StopError(orig_Awake orig, BaseSettingsControl self)
		{
			if (((Object)((Component)self).gameObject).name.Contains("VRModSetting"))
			{
				self.eventSystemLocator = ((Component)self).GetComponent<MPEventSystemLocator>();
				if (Object.op_Implicit((Object)(object)self.nameLabel) && !string.IsNullOrEmpty(self.nameToken))
				{
					self.nameLabel.token = self.nameToken;
				}
			}
			else
			{
				orig.Invoke(self);
			}
		}

		private static void SubmitConfig(orig_SubmitSettingInternal orig, BaseSettingsControl self, string newValue)
		{
			if (((Object)((Component)self).gameObject).name.Contains("VRModSetting"))
			{
				if (ModConfig.settings.TryGetValue(self.settingName, out var value))
				{
					ConfigEntryBase entry = value.entry;
					if (entry.SettingType == typeof(bool))
					{
						(entry as ConfigEntry<bool>).Value = newValue == "1";
					}
					else if (entry.SettingType == typeof(int))
					{
						float num = float.Parse(newValue);
						(entry as ConfigEntry<int>).Value = (int)num;
					}
					else if (entry.SettingType == typeof(float))
					{
						float value2 = float.Parse(newValue, CultureInfo.InvariantCulture);
						(entry as ConfigEntry<float>).Value = value2;
					}
					else if (entry.SettingType == typeof(string))
					{
						(entry as ConfigEntry<string>).Value = newValue;
					}
				}
				RoR2Application.onNextUpdate += self.OnUpdateControls;
			}
			else
			{
				orig.Invoke(self, newValue);
			}
		}

		private static string GetVRSettingValue(orig_GetCurrentValue orig, BaseSettingsControl self)
		{
			if (((Object)((Component)self).gameObject).name.Contains("VRModSetting"))
			{
				if (!ModConfig.settings.TryGetValue(self.settingName, out var value))
				{
					return "0";
				}
				ConfigEntryBase entry = value.entry;
				if (entry.SettingType == typeof(bool))
				{
					if (!(entry as ConfigEntry<bool>).Value)
					{
						return "0";
					}
					return "1";
				}
				if (entry.SettingType == typeof(int))
				{
					return TextSerialization.ToStringInvariant((entry as ConfigEntry<int>).Value);
				}
				if (entry.SettingType == typeof(float))
				{
					return TextSerialization.ToStringInvariant((entry as ConfigEntry<float>).Value);
				}
				if (entry.SettingType == typeof(string))
				{
					string value2 = (entry as ConfigEntry<string>).Value;
					if (Array.Exists(((CarouselController)((self is CarouselController) ? self : null)).choices, (Choice x) => x.convarValue == value2))
					{
						return value2;
					}
					if (self.settingName == "vr_ray_color")
					{
						return "#FFFFFF";
					}
					if (self.settingName == "vr_haptics_suit")
					{
						return "None";
					}
				}
			}
			return orig.Invoke(self);
		}

		private static void SaveOnClose(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			ILCursor val = new ILCursor(il);
			val.GotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallvirt<GameObject>(x, "SetActive")
			});
			int index = val.Index;
			val.Index = index + 1;
			val.EmitDelegate<Action>((Action)delegate
			{
				SaveSettings();
			});
		}

		private static void SaveSettings()
		{
			ModConfig.Save();
		}

		private static bool LooksLikeSettingsPanel(GameObject panel)
		{
			if (!Object.op_Implicit((Object)(object)panel))
			{
				return false;
			}
			if (!Object.op_Implicit((Object)(object)panel.GetComponent<HGHeaderNavigationController>()))
			{
				return false;
			}
			return Object.op_Implicit((Object)(object)panel.transform.Find("SafeArea/SubPanelArea"));
		}

		internal static void SetupVRSettings(GameObject panel)
		{
			try
			{
				SetupVRSettingsInternal(panel);
			}
			catch (Exception arg)
			{
				VRMod.StaticLogger.LogError((object)$"[VR settings] Could not build the VR settings tab - the settings panel hierarchy in this game build differs from what the mod expects. Details: {arg}");
				if (Object.op_Implicit((Object)(object)panel))
				{
					DumpSettingsHierarchy(panel);
				}
			}
		}

		private static void SetupVRSettingsInternal(GameObject panel)
		{
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			HGHeaderNavigationController component = panel.GetComponent<HGHeaderNavigationController>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				VRMod.StaticLogger.LogWarning((object)"[VR settings] No HGHeaderNavigationController on the settings panel; VR tab skipped.");
				return;
			}
			if (component.headers != null && component.headers.Exists((Header h) => h.headerName == "VR"))
			{
				VRMod.StaticLogger.LogInfo((object)"[VR settings] VR tab already present on this settings panel; nothing to do.");
				return;
			}
			Transform val = panel.transform.Find("SafeArea/HeaderContainer/Header (JUICED)");
			Transform val2 = panel.transform.Find("SafeArea/SubPanelArea");
			if (!Object.op_Implicit((Object)(object)val) || !Object.op_Implicit((Object)(object)val2))
			{
				VRMod.StaticLogger.LogWarning((object)$"[VR settings] Settings paths not found (header={Object.op_Implicit((Object)(object)val)}, subPanelArea={Object.op_Implicit((Object)(object)val2)}); the panel hierarchy changed in this game build. VR tab skipped.");
				DumpSettingsHierarchy(panel);
				return;
			}
			GameObject headerRoot = SetupSubPanel(val2);
			GameObject val3 = SetupHeader(val);
			val3.GetComponent<LanguageTextMeshController>().token = "VR";
			Header item = new Header
			{
				headerButton = (MPButton)(object)val3.GetComponent<HGButton>(),
				headerName = "VR",
				tmpHeaderText = (TextMeshProUGUI)(object)val3.GetComponentInChildren<HGTextMeshProUGUI>(),
				headerRoot = headerRoot
			};
			component.headers.Add(item);
			string arg = string.Join(", ", component.headers.ConvertAll((Header h) => h.headerName).ToArray());
			VRMod.StaticLogger.LogInfo((object)$"[VR settings] VR tab added ({component.headers.Count} headers now: {arg}).");
		}

		private static void DumpSettingsHierarchy(GameObject panel)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			try
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("[VR settings] Hierarchy of '" + ((Object)panel).name + "':");
				foreach (Transform item in panel.transform)
				{
					Transform val = item;
					stringBuilder.AppendLine("  " + ((Object)val).name);
					foreach (Transform item2 in val)
					{
						Transform val2 = item2;
						stringBuilder.AppendLine("    " + ((Object)val2).name);
					}
				}
				VRMod.StaticLogger.LogInfo((object)stringBuilder.ToString());
			}
			catch
			{
			}
		}

		private static GameObject SetupSubPanel(Transform parent)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = ((Component)parent.Find("SettingsSubPanel, Controls (Gamepad)")).gameObject;
			GameObject val = Object.Instantiate<GameObject>(gameObject, parent);
			Transform val2 = val.transform.Find("Scroll View/Viewport/VerticalLayout");
			foreach (Transform item in val2)
			{
				Object.Destroy((Object)(object)((Component)item).gameObject);
			}
			GameObject gameObject2 = ((Component)gameObject.transform.Find("Scroll View/Viewport/VerticalLayout/SettingsEntryButton, Slider (Look Scale X)")).gameObject;
			GameObject gameObject3 = ((Component)gameObject.transform.Find("Scroll View/Viewport/VerticalLayout/SettingsEntryButton, Bool (Invert X)")).gameObject;
			GameObject gameObject4 = ((Component)((Component)parent).transform.Find("SettingsSubPanel, Video/Scroll View/Viewport/VerticalLayout/SettingsEntryButton, Carousel (Vsync)")).gameObject;
			LanguageTextMeshController component = ((Component)((Component)parent).transform.Find("GenericDescriptionPanel/ContentSizeFitter/DescriptionText")).GetComponent<LanguageTextMeshController>();
			bool defaultFallbackButton = true;
			foreach (KeyValuePair<string, ModConfig.ConfigSetting> setting in ModConfig.settings)
			{
				ModConfig.ConfigSetting value = setting.Value;
				BaseSettingsControl component2;
				if (value.entry.SettingType == typeof(float) || value.entry.SettingType == typeof(int))
				{
					component2 = Object.Instantiate<GameObject>(gameObject2, val2).GetComponent<BaseSettingsControl>();
					BaseSettingsControl obj = ((component2 is SettingsSlider) ? component2 : null);
					((SettingsSlider)obj).minValue = value.minValue;
					((SettingsSlider)obj).maxValue = value.maxValue;
					((SettingsSlider)obj).formatString = ((value.entry.SettingType == typeof(float)) ? "{0:0.00}" : "{0:N0}");
				}
				else if (value.entry.SettingType == typeof(bool))
				{
					component2 = Object.Instantiate<GameObject>(gameObject3, val2).GetComponent<BaseSettingsControl>();
				}
				else
				{
					component2 = Object.Instantiate<GameObject>(gameObject4, val2).GetComponent<BaseSettingsControl>();
					CarouselController val3 = (CarouselController)(object)((component2 is CarouselController) ? component2 : null);
					List<Choice> list = new List<Choice>();
					if (setting.Key == "vr_ray_color")
					{
						string[] array = new string[9] { "White", "Green", "Red", "Blue", "Yellow", "Magenta", "Cyan", "Lime", "Black" };
						string[] array2 = new string[9] { "#FFFFFF", "#008000", "#FF0000", "#0000FF", "#FFFF00", "#FF00FF", "#00FFFF", "#00FF00", "#000000" };
						for (int i = 0; i < array.Length; i++)
						{
							list.Add(new Choice
							{
								convarValue = array2[i],
								suboptionDisplayToken = array[i]
							});
						}
					}
					else if (setting.Key == "vr_haptics_suit")
					{
						string[] array3 = new string[3] { "None", "Shockwave", "Bhaptics" };
						for (int j = 0; j < array3.Length; j++)
						{
							list.Add(new Choice
							{
								convarValue = array3[j],
								suboptionDisplayToken = array3[j]
							});
						}
					}
					val3.choices = list.ToArray();
				}
				component2.settingSource = (SettingSource)0;
				component2.nameToken = value.entry.Definition.Key;
				component2.settingName = setting.Key;
				((Object)((Component)component2).gameObject).name = "VRModSetting, " + component2.nameToken;
				HGButton component3 = ((Component)component2).GetComponent<HGButton>();
				if (Object.op_Implicit((Object)(object)component3))
				{
					string text = "";
					if (value.settingUpdate == ModConfig.ConfigSetting.SettingUpdate.NextStage)
					{
						text = "[WILL APPLY NEXT STAGE] ";
					}
					else if (value.settingUpdate == ModConfig.ConfigSetting.SettingUpdate.AfterRestart)
					{
						text = "[RESTART REQUIRED] ";
					}
					component3.updateTextOnHover = true;
					component3.hoverToken = text + value.entry.Description.Description;
					component3.hoverLanguageTextMeshController = component;
					((MPButton)component3).defaultFallbackButton = defaultFallbackButton;
					defaultFallbackButton = false;
				}
			}
			((Component)val.transform.Find("Scroll View")).gameObject.AddComponent<ScrollToSelection>();
			return val;
		}

		private static GameObject SetupHeader(Transform parent)
		{
			GameObject obj = Object.Instantiate<GameObject>(((Component)parent.Find("GenericHeaderButton (Graphics)")).gameObject, parent);
			obj.transform.SetSiblingIndex(parent.childCount - 2);
			((Object)obj).name = "GenericHeaderButton (VR)";
			return obj;
		}
	}
	internal class SmoothHUD : MonoBehaviour
	{
		private Quaternion smoothHUDRotation;

		private Transform referenceTransform;

		private int lastUpdateFrame;

		internal void Init(Transform referenceTransform)
		{
			//IL_0009: 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)
			this.referenceTransform = referenceTransform;
			smoothHUDRotation = referenceTransform.rotation;
		}

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

		private void OnDisable()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)referenceTransform))
			{
				smoothHUDRotation = referenceTransform.rotation;
				TransformRect();
			}
			UICamera.onUICameraPreRender -= new UICameraDelegate(UpdateHUD);
		}

		private void UpdateHUD(UICamera camera)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)referenceTransform) || lastUpdateFrame == Time.renderedFrameCount)
			{
				return;
			}
			lastUpdateFrame = Time.renderedFrameCount;
			Quaternion deriv = default(Quaternion);
			smoothHUDRotation = smoothHUDRotation.SmoothDamp(referenceTransform.rotation, ref deriv, 0.07f);
			TransformRect();
			if (!ModConfig.InitialMotionControlsValue && Object.op_Implicit((Object)(object)camera.cameraRigController) && Object.op_Implicit((Object)(object)camera.cameraRigController.hud))
			{
				CrosshairManager component = ((Component)camera.cameraRigController.hud).GetComponent<CrosshairManager>();
				if (Object.op_Implicit((Object)(object)component))
				{
					((Transform)component.container).position = ((Component)camera).transform.position + ((Component)camera).transform.forward * 12.35f;
					((Transform)component.container).rotation = ((Component)camera).transform.rotation;
					((Component)component.hitmarker).transform.position = ((Transform)component.container).position;
					((Component)component.hitmarker).transform.rotation = ((Component)camera).transform.rotation;
				}
			}
		}

		private void TransformRect()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.rotation = Quaternion.LookRotation(smoothHUDRotation * Vector3.forward, referenceTransform.up);
			((Component)this).transform.position = referenceTransform.position + ((Component)this).transform.forward * 12.35f;
		}
	}
	internal class ReportPlayerPaging : MonoBehaviour
	{
		private GameEndReportPanelController panel;

		private float nextAllowed;

		private void Awake()
		{
			panel = ((Component)this).GetComponent<GameEndReportPanelController>();
		}

		private void Update()
		{
			if (!Object.op_Implicit((Object)(object)panel) || !Object.op_Implicit((Object)(object)panel.playerNavigationController) || Time.unscaledTime < nextAllowed)
			{
				return;
			}
			LocalUser firstLocalUser = LocalUserManager.GetFirstLocalUser();
			Player val = ((firstLocalUser != null) ? firstLocalUser.inputPlayer : null);
			if (val != null)
			{
				bool flag = false;
				bool flag2 = false;
				try
				{
					flag = val.GetButtonDown("UIPageLeft");
					flag2 = val.GetButtonDown("UIPageRight");
				}
				catch
				{
					return;
				}
				if (flag)
				{
					panel.playerNavigationController.NavigatePreviousPage();
					nextAllowed = Time.unscaledTime + 0.25f;
				}
				else if (flag2)
				{
					panel.playerNavigationController.NavigateNextPage();
					nextAllowed = Time.unscaledTime + 0.25f;
				}
			}
		}
	}
	internal static class UIFixes
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_UpdateAllHealthbarPositions <0>__UpdateAllHealthBarPositionsVR;

			public static hook_PositionForUI <1>__PositionForUIOverride;

			public static hook_UpdatePositions <2>__UpdatePositionsOverride;

			public static hook_GenerateReportScreen <3>__UnparentHUD;

			public static hook_Awake <4>__OpenPopupInMenuCanvas;

			public static hook_OpenCreateProfileMenu <5>__SetAddProfileButtonAsDefaultFallback;

			public static hook_OnEnable <6>__MoveCreditsToWorldSpace;

			public static hook_OnDisplayBegin <7>__MovePickerPanelToWorld;

			public static hook_OnDisplayEnd <8>__DestroyPickerPanelCanvas;

			public static hook_OnActiveSceneChanged <9>__ChangeDialogScene;

			public static hook_OnOverlayInstanceAdded <10>__MoveOverlayNextToHealth;

			public static hook_OnEnable <11>__SeekerOnEnable;

			public static hook_OnEnter <12>__SeekerMeditateOnEnter;

			public static hook_SetupInputUIIcons <13>__SeekerMeditateSetupInputUIIcons;

			public static hook_UpdateCrosshair <14>__HideCrosshair;

			public static hook_OnTransformParentChanged <15>__FixHUDReference;

			public static Action <16>__MoveOverlayAgainWhyDoINeedToDoThis;

			public static Action <17>__RepositionSeekerLotus;

			public static Action <18>__CorrectSeekerLotusPosition;

			public static Action <19>__RepositionSeekerMeditate;

			public static Action <20>__CorrectSeekerMeditatePosition;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Action <>9__18_0;

			public static hook_OnEnter <>9__18_1;

			public static hook_Awake <>9__18_2;

			public static hook_Start <>9__18_3;

			public static hook_Awake <>9__18_4;

			public static hook_OnEnable <>9__18_5;

			public static hook_OnEnable <>9__18_6;

			public static hook_Awake <>9__18_7;

			public static hook_Awake <>9__18_8;

			public static hook_Start <>9__18_9;

			public static hook_Awake <>9__18_10;

			public static hook_Start <>9__18_11;

			public static hook_Awake <>9__18_12;

			public static hook_Awake <>9__18_13;

			public static hook_Awake <>9__18_14;

			public static hook_OnDestroy <>9__18_15;

			public static hook_GenerateReportScreen <>9__18_16;

			public static hook_HandleKick_NetworkMessage <>9__18_17;

			public static hook_HandleKick_string <>9__18_18;

			internal void <Init>b__18_0()
			{
				RoR2Application.instance.mainCanvas.renderMode = (RenderMode)1;
			}

			internal void <Init>b__18_1(orig_OnEnter orig, BaseMainMenuScreen self, MainMenuController controller)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self, controller);
				CanvasToWorldSpace(((Component)self).gameObject, menuResolution, menuPosition, menuScale, addCollider: true);
			}

			internal void <Init>b__18_2(orig_Awake orig, MultiplayerMenuController self)
			{
				orig.Invoke(self);
				((Component)self).gameObject.layer = LayerIndex.ui.intVal;
			}

			internal void <Init>b__18_3(orig_Start orig, LogBookController self)
			{
				//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_0017: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self);
				CanvasToWorldSpace(((Component)self).gameObject, hdResolution, menuPosition, menuScale, addCollider: true);
			}

			internal void <Init>b__18_4(orig_Awake orig, EclipseRunScreenController self)
			{
				//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_0017: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self);
				CanvasToWorldSpace(((Component)self).gameObject, hdResolution, menuPosition, menuScale, addCollider: true);
			}

			internal void <Init>b__18_5(orig_OnEnable orig, CharacterSelectController self)
			{
				<>c__DisplayClass18_0 CS$<>8__locals4 = new <>c__DisplayClass18_0
				{
					self = self
				};
				orig.Invoke(CS$<>8__locals4.self);
				Transform val = ((Component)CS$<>8__locals4.self).transform.Find("TopSideFade");
				if (Object.op_Implicit((Object)(object)val))
				{
					((Component)val).gameObject.SetActive(false);
				}
				Transform val2 = ((Component)CS$<>8__locals4.self).transform.Find("BottomSideFade");
				if (Object.op_Implicit((Object)(object)val2))
				{
					((Component)val2).gameObject.SetActive(false);
				}
				RoR2Application.onNextUpdate += delegate
				{
					//IL_000b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0010: Unknown result type (might be due to invalid IL or missing references)
					//IL_0015: Unknown result type (might be due to invalid IL or missing references)
					CanvasToWorldSpace(((Component)CS$<>8__locals4.self).gameObject, hdResolution, characterSelectPosition, characterSelectScale, addCollider: true);
				};
			}

			internal void <Init>b__18_6(orig_OnEnable orig, PauseScreenController self)
			{
				//IL_001e: 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_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self);
				if (GetUICamera())
				{
					camRotation = new Vector3(0f, ((Component)cachedUICam).transform.eulerAngles.y, 0f);
					CanvasToWorldSpace(((Component)self).gameObject, hdResolution, menuPosition, menuScale, addCollider: true, followRotation: true);
					Canvas component = ((Component)self).GetComponent<Canvas>();
					if (Object.op_Implicit((Object)(object)component))
					{
						component.overrideSorting = true;
						component.sortingOrder = 200;
					}
				}
			}

			internal void <Init>b__18_7(orig_Awake orig, EquipmentIcon self)
			{
				if (Object.op_Implicit((Object)(object)((Component)self).GetComponentInParent<HUD>()))
				{
					orig.Invoke(self);
					return;
				}
				self.eventSystemLocator = ((Component)self).GetComponent<MPEventSystemLocator>();
				self.NavButtonToEnable = ((Component)self).GetComponent<HGButton>();
				self.inspectPanelLocator = ((Component)self).GetComponent<InspectPanelLocator>();
				LocalUser firstLocalUser = LocalUserManager.GetFirstLocalUser();
				self.userProfile = ((firstLocalUser != null) ? firstLocalUser.userProfile : null);
				if (Object.op_Implicit((Object)(object)self.cooldownText))
				{
					((Component)self.cooldownText).gameObject.SetActive(false);
				}
			}

			internal void <Init>b__18_8(orig_Awake orig, ItemIcon self)
			{
				if (Object.op_Implicit((Object)(object)((Component)self).GetComponentInParent<HUD>()))
				{
					orig.Invoke(self);
					return;
				}
				self.CacheRectTransform();
				self.inspectPanelLocator = ((Component)self).GetComponent<InspectPanelLocator>();
				LocalUser firstLocalUser = LocalUserManager.GetFirstLocalUser();
				self.userProfile = ((firstLocalUser != null) ? firstLocalUser.userProfile : null);
			}

			internal void <Init>b__18_9(orig_Start orig, SimpleDialogBox self)
			{
				//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_0017: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self);
				CanvasToWorldSpace(self.rootObject, hdResolution, menuPosition, menuScale, addCollider: true, PauseManager.isPaused);
				Canvas val = (Object.op_Implicit((Object)(object)self.rootObject) ? self.rootObject.GetComponentInChildren<Canvas>(true) : null);
				if (Object.op_Implicit((Object)(object)val))
				{
					val.overrideSorting = true;
					val.sortingOrder = 300;
				}
			}

			internal void <Init>b__18_10(orig_Awake orig, GameEndReportPanelController self)
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self);
				if (!Object.op_Implicit((Object)(object)((Component)self).GetComponent<ReportPlayerPaging>()))
				{
					((Component)self).gameObject.AddComponent<ReportPlayerPaging>();
				}
				if (GetUICamera())
				{
					camRotation = new Vector3(0f, ((Component)cachedUICam).transform.eulerAngles.y, 0f);
					float num = Mathf.Clamp(ModConfig.ReportTextZoom.Value, 1f, 4f);
					float num2 = Mathf.Clamp(ModConfig.ReportWidthMeters.Value, 4f, 24f);
					Vector2 val = hdResolution / num;
					float num3 = num2 / val.x;
					CanvasToWorldSpace(((Component)self).gameObject, val, menuPosition, new Vector3(num3, num3, num3), addCollider: true, followRotation: true);
					Canvas component = ((Component)self).GetComponent<Canvas>();
					if (Object.op_Implicit((Object)(object)component))
					{
						component.overrideSorting = true;
						component.sortingOrder = 10;
					}
				}
			}

			internal void <Init>b__18_11(orig_Start orig, SplashScreenController self)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self);
				Camera.main.clearFlags = (CameraClearFlags)2;
				Camera.main.backgroundColor = Color.black;
				GameObject val = GameObject.Find("SpashScreenCanvas");
				if (Object.op_Implicit((Object)(object)val))
				{
					CanvasToWorldSpace(val, hdResolution, menuPosition, menuScale, addCollider: false);
				}
				if (Object.op_Implicit((Object)(object)Camera.main) && (Object)(object)Camera.main != (Object)(object)cachedUICam)
				{
					Camera main = Camera.main;
					main.cullingMask &= ~(1 << LayerIndex.ui.intVal);
				}
			}

			internal void <Init>b__18_12(orig_Awake orig, InfiniteTowerMenuController self)
			{
				//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_0017: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self);
				CanvasToWorldSpace(((Component)self).gameObject, hdResolution, menuPosition, menuScale, addCollider: true);
			}

			internal void <Init>b__18_13(orig_Awake orig, GameOverController self)
			{
				orig.Invoke(self);
				self.gameEndReportPanelPrefab.GetComponent<Canvas>().renderMode = (RenderMode)0;
			}

			internal void <Init>b__18_14(orig_Awake orig, RemoteGameBrowserController self)
			{
				orig.Invoke(self);
				cachedMultiplayerCanvas = ((Component)self).GetComponentInParent<Canvas>();
			}

			internal void <Init>b__18_15(orig_OnDestroy orig, CameraRigController self)
			{
				orig.Invoke(self);
				if (Object.op_Implicit((Object)(object)livHUD))
				{
					Object.Destroy((Object)(object)((Component)livHUD).gameObject);
				}
			}

			internal GameEndReportPanelController <Init>b__18_16(orig_GenerateReportScreen orig, GameOverController self, HUD hud)
			{
				if ((Object)(object)hud != (Object)(object)livHUD)
				{
					return orig.Invoke(self, hud);
				}
				return null;
			}

			internal void <Init>b__18_17(orig_HandleKick_NetworkMessage orig, NetworkMessage netMsg)
			{
				orig.Invoke(netMsg);
				UnparentDialogBoxInternal();
			}

			internal void <Init>b__18_18(orig_HandleKick_string orig, string token)
			{
				orig.Invoke(token);
				UnparentDialogBoxInternal();
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass18_0
		{
			public CharacterSelectController self;

			internal void <Init>b__19()
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				CanvasToWorldSpace(((Component)self).gameObject, hdResolution, characterSelectPosition, characterSelectScale, addCollider: true);
			}
		}

		private static readonly Vector3 menuPosition = new Vector3(0f, 0f, 15f);

		private static readonly Vector3 characterSelectPosition = new Vector3(0f, 0f, 5f);

		private static readonly Vector3 menuScale = new Vector3(0.01f, 0.01f, 0.01f);

		private static readonly Vector3 characterSelectScale = new Vector3(0.005f, 0.005f, 0.005f);

		private static readonly Vector2 menuPivot = new Vector2(0.5f, 0.5f);

		private static readonly Vector2 menuResolution = new Vector2(1500f, 1000f);

		private static readonly Vector2 hdResolution = new Vector2(1920f, 1080f);

		private static readonly Vector2 gameDetailsResolution = new Vector2(450f, 300f);

		private static Camera cachedUICam;

		private static Vector3 camRotation;

		private static Canvas cachedMultiplayerCanvas;

		private static GameObject creditsCanvasPrefab;

		private static GameObject creditsCanvas;

		private static GameObject pickerCanvasPrefab;

		internal static GameObject queuedKickDialog;

		private static Transform voidFiendCorruptionMeter;

		private static GameObject pickerCanvas;

		internal static HUD livHUD;

		private static readonly FieldInfo seekerOverlayControllerField = typeof(SeekerController).GetField("overlayController", BindingFlags.Instance | BindingFlags.NonPublic);

		private static readonly FieldInfo meditateOverlayControllerField = typeof(Meditate).GetField("overlayController", BindingFlags.Instance | BindingFlags.NonPublic);

		private static readonly FieldInfo meditateChildLocatorField = typeof(Meditate).GetField("overlayInstanceChildLocator", BindingFlags.Instance | BindingFlags.NonPublic);

		private static readonly string[] meditateArrowChildNames = new string[5] { "ArrowInput1", "ArrowInput2", "ArrowInput3", "ArrowInput4", "ArrowInput5" };

		private static RectTransform seekerLotusInstance;

		private static RectTransform seekerMeditateInstance;

		private static Vector3 meditateLocalPos;

		private static Vector3 meditateLocalScale;

		internal static void Init()
		{
			//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_0043: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected O, but got Unknown
			//IL_0137: 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_0142: Expected O, but got Unknown
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Expected O, but got Unknown
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Expected O, but got Unknown
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Expected O, but got Unknown
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Expected O, but got Unknown
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Expected O, but got Unknown
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Expected O, but got Unknown
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Expected O, but got Unknown
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Expected O, but got Unknown
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Expected O, but got Unknown
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Expected O, but got Unknown
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Expected O, but got Unknown
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Expected O, but got Unknown
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Expected O, but got Unknown
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Expected O, but got Unknown
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Expected O, but got Unknown
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Expected O, but got Unknown
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Expected O, but got Unknown
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Expected O, but got Unknown
			//IL_03cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03da: Expected O, but got Unknown
			//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Expected O, but got Unknown
			//IL_0413: Unknown result type (might be due to invalid IL or missing references)
			//IL_0418: Unknown result type (might be due to invalid IL or missing references)
			//IL_041e: Expected O, but got Unknown
			//IL_0433: Unknown result type (might be due to invalid IL or missing references)
			//IL_0438: Unknown result type (might be due to invalid IL or missing references)
			//IL_043e: Expected O, but got Unknown
			//IL_0453: Unknown result type (might be due to invalid IL or missing references)
			//IL_0458: Unknown result type (might be due to invalid IL or missing references)
			//IL_045e: Expected O, but got Unknown
			//IL_0473: Unknown result type (might be due to invalid IL or missing references)
			//IL_0478: Unknown result type (might be due to invalid IL or missing references)
			//IL_047e: Expected O, but got Unknown
			//IL_0493: Unknown result type (might be due to invalid IL or missing references)
			//IL_0498: Unknown result type (might be due to invalid IL or missing references)
			//IL_049e: Expected O, but got Unknown
			//IL_04ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c5: Expected O, but got Unknown
			//IL_04da: Unknown result type (might be due to invalid IL or missing references)
			//IL_04df: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e5: Expected O, but got Unknown
			creditsCanvasPrefab = VRMod.VRAssetBundle.LoadAsset<GameObject>("CreditsCanvas");
			pickerCanvasPrefab = VRMod.VRAssetBundle.LoadAsset<GameObject>("PickerCanvas");
			object obj = <>O.<0>__UpdateAllHealthBarPositionsVR;
			if (obj == null)
			{
				hook_UpdateAllHealthbarPositions val = UpdateAllHealthBarPositionsVR;
				<>O.<0>__UpdateAllHealthBarPositionsVR = val;
				obj = (object)val;
			}
			CombatHealthBarViewer.UpdateAllHealthbarPositions += (hook_UpdateAllHealthbarPositions)obj;
			object obj2 = <>O.<1>__PositionForUIOverride;
			if (obj2 == null)
			{
				hook_PositionForUI val2 = PositionForUIOverride;
				<>O.<1>__PositionForUIOverride = val2;
				obj2 = (object)val2;
			}
			Indicator.PositionForUI += (hook_PositionForUI)obj2;
			object obj3 = <>O.<2>__UpdatePositionsOverride;
			if (obj3 == null)
			{
				hook_UpdatePositions val3 = UpdatePositionsOverride;
				<>O.<2>__UpdatePositionsOverride = val3;
				obj3 = (object)val3;
			}
			PositionIndicator.UpdatePositions += (hook_UpdatePositions)obj3;
			object obj4 = <>O.<3>__UnparentHUD;
			if (obj4 == null)
			{
				hook_GenerateReportScreen val4 = UnparentHUD;
				<>O.<3>__UnparentHUD = val4;
				obj4 = (object)val4;
			}
			GameOverController.GenerateReportScreen += (hook_GenerateReportScreen)obj4;
			RoR2Application.onLoad = (Action)Delegate.Combine(RoR2Application.onLoad, (Action)delegate
			{
				RoR2Application.instance.mainCanvas.renderMode = (RenderMode)1;
			});
			object obj5 = <>c.<>9__18_1;
			if (obj5 == null)
			{
				hook_OnEnter val5 = delegate(orig_OnEnter orig, BaseMainMenuScreen self, MainMenuController controller)
				{
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0013: Unknown result type (might be due to invalid IL or missing references)
					//IL_0018: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self, controller);
					CanvasToWorldSpace(((Component)self).gameObject, menuResolution, menuPosition, menuScale, addCollider: true);
				};
				<>c.<>9__18_1 = val5;
				obj5 = (object)val5;
			}
			BaseMainMenuScreen.OnEnter += (hook_OnEnter)obj5;
			object obj6 = <>c.<>9__18_2;
			if (obj6 == null)
			{
				hook_Awake val6 = delegate(orig_Awake orig, MultiplayerMenuController self)
				{
					orig.Invoke(self);
					((Component)self).gameObject.layer = LayerIndex.ui.intVal;
				};
				<>c.<>9__18_2 = val6;
				obj6 = (object)val6;
			}
			MultiplayerMenuController.Awake += (hook_Awake)obj6;
			object obj7 = <>c.<>9__18_3;
			if (obj7 == null)
			{
				hook_Start val7 = delegate(orig_Start orig, LogBookController self)
				{
					//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_0017: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self);
					CanvasToWorldSpace(((Component)self).gameObject, hdResolution, menuPosition, menuScale, addCollider: true);
				};
				<>c.<>9__18_3 = val7;
				obj7 = (object)val7;
			}
			LogBookController.Start += (hook_Start)obj7;
			object obj8 = <>c.<>9__18_4;
			if (obj8 == null)
			{
				hook_Awake val8 = delegate(orig_Awake orig, EclipseRunScreenController self)
				{
					//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_0017: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self);
					CanvasToWorldSpace(((Component)self).gameObject, hdResolution, menuPosition, menuScale, addCollider: true);
				};
				<>c.<>9__18_4 = val8;
				obj8 = (object)val8;
			}
			EclipseRunScreenController.Awake += (hook_Awake)obj8;
			object obj9 = <>c.<>9__18_5;
			if (obj9 == null)
			{
				hook_OnEnable val9 = delegate(orig_OnEnable orig, CharacterSelectController self)
				{
					orig.Invoke(self);
					Transform val35 = ((Component)self).transform.Find("TopSideFade");
					if (Object.op_Implicit((Object)(object)val35))
					{
						((Component)val35).gameObject.SetActive(false);
					}
					Transform val36 = ((Component)self).transform.Find("BottomSideFade");
					if (Object.op_Implicit((Object)(object)val36))
					{
						((Component)val36).gameObject.SetActive(false);
					}
					RoR2Application.onNextUpdate += delegate
					{
						//IL_000b: Unknown result type (might be due to invalid IL or missing references)
						//IL_0010: Unknown result type (might be due to invalid IL or missing references)
						//IL_0015: Unknown result type (might be due to invalid IL or missing references)
						CanvasToWorldSpace(((Component)self).gameObject, hdResolution, characterSelectPosition, characterSelectScale, addCollider: true);
					};
				};
				<>c.<>9__18_5 = val9;
				obj9 = (object)val9;
			}
			CharacterSelectController.OnEnable += (hook_OnEnable)obj9;
			object obj10 = <>c.<>9__18_6;
			if (obj10 == null)
			{
				hook_OnEnable val10 = delegate(orig_OnEnable orig, PauseScreenController self)
				{
					//IL_001e: 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_0032: Unknown result type (might be due to invalid IL or missing references)
					//IL_003d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0042: Unknown result type (might be due to invalid IL or missing references)
					//IL_0047: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self);
					if (GetUICamera())
					{
						camRotation = new Vector3(0f, ((Component)cachedUICam).transform.eulerAngles.y, 0f);
						CanvasToWorldSpace(((Component)self).gameObject, hdResolution, menuPosition, menuScale, addCollider: true, followRotation: true);
						Canvas component = ((Component)self).GetComponent<Canvas>();
						if (Object.op_Implicit((Object)(object)component))
						{
							component.overrideSorting = true;
							component.sortingOrder = 200;
						}
					}
				};
				<>c.<>9__18_6 = val10;
				obj10 = (object)val10;
			}
			PauseScreenController.OnEnable += (hook_OnEnable)obj10;
			object obj11 = <>c.<>9__18_7;
			if (obj11 == null)
			{
				hook_Awake val11 = delegate(orig_Awake orig, EquipmentIcon self)
				{
					if (Object.op_Implicit((Object)(object)((Component)self).GetComponentInParent<HUD>()))
					{
						orig.Invoke(self);
					}
					else
					{
						self.eventSystemLocator = ((Component)self).GetComponent<MPEventSystemLocator>();
						self.NavButtonToEnable = ((Component)self).GetComponent<HGButton>();
						self.inspectPanelLocator = ((Component)self).GetComponent<InspectPanelLocator>();
						LocalUser firstLocalUser = LocalUserManager.GetFirstLocalUser();
						self.userProfile = ((firstLocalUser != null) ? firstLocalUser.userProfile : null);
						if (Object.op_Implicit((Object)(object)self.cooldownText))
						{
							((Component)self.cooldownText).gameObject.SetActive(false);
						}
					}
				};
				<>c.<>9__18_7 = val11;
				obj11 = (object)val11;
			}
			EquipmentIcon.Awake += (hook_Awake)obj11;
			object obj12 = <>c.<>9__18_8;
			if (obj12 == null)
			{
				hook_Awake val12 = delegate(orig_Awake orig, ItemIcon self)
				{
					if (Object.op_Implicit((Object)(object)((Component)self).GetComponentInParent<HUD>()))
					{
						orig.Invoke(self);
					}
					else
					{
						self.CacheRectTransform();
						self.inspectPanelLocator = ((Component)self).GetComponent<InspectPanelLocator>();
						LocalUser firstLocalUser = LocalUserManager.GetFirstLocalUser();
						self.userProfile = ((firstLocalUser != null) ? firstLocalUser.userProfile : null);
					}
				};
				<>c.<>9__18_8 = val12;
				obj12 = (object)val12;
			}
			ItemIcon.Awake += (hook_Awake)obj12;
			object obj13 = <>c.<>9__18_9;
			if (obj13 == null)
			{
				hook_Start val13 = delegate(orig_Start orig, SimpleDialogBox self)
				{
					//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_0017: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self);
					CanvasToWorldSpace(self.rootObject, hdResolution, menuPosition, menuScale, addCollider: true, PauseManager.isPaused);
					Canvas val35 = (Object.op_Implicit((Object)(object)self.rootObject) ? self.rootObject.GetComponentInChildren<Canvas>(true) : null);
					if (Object.op_Implicit((Object)(object)val35))
					{
						val35.overrideSorting = true;
						val35.sortingOrder = 300;
					}
				};
				<>c.<>9__18_9 = val13;
				obj13 = (object)val13;
			}
			SimpleDialogBox.Start += (hook_Start)obj13;
			object obj14 = <>c.<>9__18_10;
			if (obj14 == null)
			{
				hook_Awake val14 = delegate(orig_Awake orig, GameEndReportPanelController self)
				{
					//IL_0037: Unknown result type (might be due to invalid IL or missing references)
					//IL_0046: Unknown result type (might be due to invalid IL or missing references)
					//IL_004b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0083: Unknown result type (might be due to invalid IL or missing references)
					//IL_0089: Unknown result type (might be due to invalid IL or missing references)
					//IL_008e: Unknown result type (might be due to invalid IL or missing references)
					//IL_008f: Unknown result type (might be due to invalid IL or missing references)
					//IL_009d: Unknown result type (might be due to invalid IL or missing references)
					//IL_009e: Unknown result type (might be due to invalid IL or missing references)
					//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self);
					if (!Object.op_Implicit((Object)(object)((Component)self).GetComponent<ReportPlayerPaging>()))
					{
						((Component)self).gameObject.AddComponent<ReportPlayerPaging>();
					}
					if (GetUICamera())
					{
						camRotation = new Vector3(0f, ((Component)cachedUICam).transform.eulerAngles.y, 0f);
						float num = Mathf.Clamp(ModConfig.ReportTextZoom.Value, 1f, 4f);
						float num2 = Mathf.Clamp(ModConfig.ReportWidthMeters.Value, 4f, 24f);
						Vector2 val35 = hdResolution / num;
						float num3 = num2 / val35.x;
						CanvasToWorldSpace(((Component)self).gameObject, val35, menuPosition, new Vector3(num3, num3, num3), addCollider: true, followRotation: true);
						Canvas component = ((Component)self).GetComponent<Canvas>();
						if (Object.op_Implicit((Object)(object)component))
						{
							component.overrideSorting = true;
							component.sortingOrder = 10;
						}
					}
				};
				<>c.<>9__18_10 = val14;
				obj14 = (object)val14;
			}
			GameEndReportPanelController.Awake += (hook_Awake)obj14;
			object obj15 = <>c.<>9__18_11;
			if (obj15 == null)
			{
				hook_Start val15 = delegate(orig_Start orig, SplashScreenController self)
				{
					//IL_0017: Unknown result type (might be due to invalid IL or missing references)
					//IL_0035: Unknown result type (might be due to invalid IL or missing references)
					//IL_003a: Unknown result type (might be due to invalid IL or missing references)
					//IL_003f: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self);
					Camera.main.clearFlags = (CameraClearFlags)2;
					Camera.main.backgroundColor = Color.black;
					GameObject val35 = GameObject.Find("SpashScreenCanvas");
					if (Object.op_Implicit((Object)(object)val35))
					{
						CanvasToWorldSpace(val35, hdResolution, menuPosition, menuScale, addCollider: false);
					}
					if (Object.op_Implicit((Object)(object)Camera.main) && (Object)(object)Camera.main != (Object)(object)cachedUICam)
					{
						Camera main = Camera.main;
						main.cullingMask &= ~(1 << LayerIndex.ui.intVal);
					}
				};
				<>c.<>9__18_11 = val15;
				obj15 = (object)val15;
			}
			SplashScreenController.Start += (hook_Start)obj15;
			object obj16 = <>c.<>9__18_12;
			if (obj16 == null)
			{
				hook_Awake val16 = delegate(orig_Awake orig, InfiniteTowerMenuController self)
				{
					//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_0017: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self);
					CanvasToWorldSpace(((Component)self).gameObject, hdResolution, menuPosition, menuScale, addCollider: true);
				};
				<>c.<>9__18_12 = val16;
				obj16 = (object)val16;
			}
			InfiniteTowerMenuController.Awake += (hook_Awake)obj16;
			object obj17 = <>c.<>9__18_13;
			if (obj17 == null)
			{
				hook_Awake val17 = delegate(orig_Awake orig, GameOverController self)
				{
					orig.Invoke(self);
					self.gameEndReportPanelPrefab.GetComponent<Canvas>().renderMode = (RenderMode)0;
				};
				<>c.<>9__18_13 = val17;
				obj17 = (object)val17;
			}
			GameOverController.Awake += (hook_Awake)obj17;
			object obj18 = <>c.<>9__18_14;
			if (obj18 == null)
			{
				hook_Awake val18 = delegate(orig_Awake orig, RemoteGameBrowserController self)
				{
					orig.Invoke(self);
					cachedMultiplayerCanvas = ((Component)self).GetComponentInParent<Canvas>();
				};
				<>c.<>9__18_14 = val18;
				obj18 = (object)val18;
			}
			RemoteGameBrowserController.Awake += (hook_Awake)obj18;
			object obj19 = <>O.<4>__OpenPopupInMenuCanvas;
			if (obj19 == null)
			{
				hook_Awake val19 = OpenPopupInMenuCanvas;
				<>O.<4>__OpenPopupInMenuCanvas = val19;
				obj19 = (object)val19;
			}
			RemoteGameDetailsPanelController.Awake += (hook_Awake)obj19;
			object obj20 = <>O.<5>__SetAddProfileButtonAsDefaultFallback;
			if (obj20 == null)
			{
				hook_OpenCreateProfileMenu val20 = SetAddProfileButtonAsDefaultFallback;
				<>O.<5>__SetAddProfileButtonAsDefaultFallback = val20;
				obj20 = (object)val20;
			}
			ProfileMainMenuScreen.OpenCreateProfileMenu += (hook_OpenCreateProfileMenu)obj20;
			object obj21 = <>O.<6>__MoveCreditsToWorldSpace;
			if (obj21 == null)
			{
				hook_OnEnable val21 = MoveCreditsToWorldSpace;
				<>O.<6>__MoveCreditsToWorldSpace = val21;
				obj21 = (object)val21;
			}
			CreditsController.OnEnable += (hook_OnEnable)obj21;
			object obj22 = <>c.<>9__18_15;
			if (obj22 == null)
			{
				hook_OnDestroy val22 = delegate(orig_OnDestroy orig, CameraRigController self)
				{
					orig.Invoke(self);
					if (Object.op_Implicit((Object)(object)livHUD))
					{
						Object.Destroy((Object)(object)((Component)livHUD).gameObject);
					}
				};
				<>c.<>9__18_15 = val22;
				obj22 = (object)val22;
			}
			CameraRigController.OnDestroy += (hook_OnDestroy)obj22;
			object obj23 = <>c.<>9__18_16;
			if (obj23 == null)
			{
				hook_GenerateReportScreen val23 = (orig_GenerateReportScreen orig, GameOverController self, HUD hud) => ((Object)(object)hud != (Object)(object)livHUD) ? orig.Invoke(self, hud) : null;
				<>c.<>9__18_16 = val23;
				obj23 = (object)val23;
			}
			GameOverController.GenerateReportScreen += (hook_GenerateReportScreen)obj23;
			object obj24 = <>O.<7>__MovePickerPanelToWorld;
			if (obj24 == null)
			{
				hook_OnDisplayBegin val24 = MovePickerPanelToWorld;
				<>O.<7>__MovePickerPanelToWorld = val24;
				obj24 = (object)val24;
			}
			PickupPickerController.OnDisplayBegin += (hook_OnDisplayBegin)obj24;
			object obj25 = <>O.<8>__DestroyPickerPanelCanvas;
			if (obj25 == null)
			{
				hook_OnDisplayEnd val25 = DestroyPickerPanelCanvas;
				<>O.<8>__DestroyPickerPanelCanvas = val25;
				obj25 = (object)val25;
			}
			PickupPickerController.OnDisplayEnd += (hook_OnDisplayEnd)obj25;
			object obj26 = <>c.<>9__18_17;
			if (obj26 == null)
			{
				hook_HandleKick_NetworkMessage val26 = delegate(orig_HandleKick_NetworkMessage orig, NetworkMessage netMsg)
				{
					orig.Invoke(netMsg);
					UnparentDialogBoxInternal();
				};
				<>c.<>9__18_17 = val26;
				obj26 = (object)val26;
			}
			NetworkManagerSystem.HandleKick_NetworkMessage += (hook_HandleKick_NetworkMessage)obj26;
			object obj27 = <>c.<>9__18_18;
			if (obj27 == null)
			{
				hook_HandleKick_string val27 = delegate(orig_HandleKick_string orig, string token)
				{
					orig.Invoke(token);
					UnparentDialogBoxInternal();
				};
				<>c.<>9__18_18 = val27;
				obj27 = (object)val27;
			}
			NetworkManagerSystem.HandleKick_string += (hook_HandleKick_string)obj27;
			object obj28 = <>O.<9>__ChangeDialogScene;
			if (obj28 == null)
			{
				hook_OnActiveSceneChanged val28 = ChangeDialogScene;
				<>O.<9>__ChangeDialogScene = val28;
				obj28 = (object)val28;
			}
			SceneCatalog.OnActiveSceneChanged += (hook_OnActiveSceneChanged)obj28;
			object obj29 = <>O.<10>__MoveOverlayNextToHealth;
			if (obj29 == null)
			{
				hook_OnOverlayInstanceAdded val29 = MoveOverlayNextToHealth;
				<>O.<10>__MoveOverlayNextToHealth = val29;
				obj29 = (object)val29;
			}
			VoidSurvivorController.OnOverlayInstanceAdded += (hook_OnOverlayInstanceAdded)obj29;
			object obj30 = <>O.<11>__SeekerOnEnable;
			if (obj30 == null)
			{
				hook_OnEnable val30 = SeekerOnEnable;
				<>O.<11>__SeekerOnEnable = val30;
				obj30 = (object)val30;
			}
			SeekerController.OnEnable += (hook_OnEnable)obj30;
			object obj31 = <>O.<12>__SeekerMeditateOnEnter;
			if (obj31 == null)
			{
				hook_OnEnter val31 = SeekerMeditateOnEnter;
				<>O.<12>__SeekerMeditateOnEnter = val31;
				obj31 = (object)val31;
			}
			Meditate.OnEnter += (hook_OnEnter)obj31;
			object obj32 = <>O.<13>__SeekerMeditateSetupInputUIIcons;
			if (obj32 == null)
			{
				hook_SetupInputUIIcons val32 = SeekerMeditateSetupInputUIIcons;
				<>O.<13>__SeekerMeditateSetupInputUIIcons = val32;
				obj32 = (object)val32;
			}
			Meditate.SetupInputUIIcons += (hook_SetupInputUIIcons)obj32;
			if (ModConfig.InitialMotionControlsValue)
			{
				object obj33 = <>O.<14>__HideCrosshair;
				if (obj33 == null)
				{
					hook_UpdateCrosshair val33 = HideCrosshair;
					<>O.<14>__HideCrosshair = val33;
					obj33 = (object)val33;
				}
				CrosshairManager.UpdateCrosshair += (hook_UpdateCrosshair)obj33;
				object obj34 = <>O.<15>__FixHUDReference;
				if (obj34 == null)
				{
					hook_OnTransformParentChanged val34 = FixHUDReference;
					<>O.<15>__FixHUDReference = val34;
					obj34 = (object)val34;
				}
				SniperTargetViewer.OnTransformParentChanged += (hook_OnTransformParentChanged)obj34;
			}
		}

		private static void FixHUDReference(orig_OnTransformParentChanged orig, SniperTargetViewer self)
		{
			orig.Invoke(self);
			if (!Object.op_Implicit((Object)(object)self.hud))
			{
				self.hud = Utils.localCameraRig.hud;
			}
		}

		private static void MoveOverlayNextToHealth(orig_OnOverlayInstanceAdded orig, VoidSurvivorController self, OverlayController controller, GameObject instance)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self, controller, instance);
			if (ModConfig.TempWristHUDValue && self.characterBody.IsLocalBody() && Object.op_Implicit((Object)(object)Utils.localCameraRig) && Object.op_Implicit((Object)(object)Utils.localCameraRig.hud))
			{
				Transform transform = ((Component)Utils.localCameraRig.hud.healthBar).transform;
				RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				instance.transform.SetParent((Transform)(object)val);
				Transform transform2 = instance.transform;
				Transform obj = ((transform2 is RectTransform) ? transform2 : null);
				Transform obj2 = obj.Find("FillRoot");
				RectTransform val2 = (RectTransform)(object)((obj2 is RectTransform) ? obj2 : null);
				obj.localRotation = Quaternion.identity;
				((RectTransform)obj).sizeDelta = new Vector2(val2.sizeDelta.y, val2.sizeDelta.y);
				((Transform)val2).localPosition = Vector3.zero;
				((RectTransform)obj).anchorMin = new Vector2(1f, 0.5f);
				((RectTransform)obj).anchorMax = new Vector2(1f, 0.5f);
				((RectTransform)obj).pivot = new Vector2(1f, 0.5f);
				obj.localPosition = new Vector3(0f, val.sizeDelta.y / 2f, 0f);
				voidFiendCorruptionMeter = obj;
				RoR2Application.onNextUpdate += MoveOverlayAgainWhyDoINeedToDoThis;
			}
		}

		private static void MoveOverlayAgainWhyDoINeedToDoThis()
		{
			//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_0028: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)voidFiendCorruptionMeter))
			{
				Vector3 localPosition = voidFiendCorruptionMeter.localPosition;
				localPosition.x = 0f;
				voidFiendCorruptionMeter.localPosition = localPosition;
			}
		}

		private static RectTransform GetLocalHealthbarTransform()
		{
			if (!Object.op_Implicit((Object)(object)Utils.localCameraRig) || !Object.op_Implicit((Object)(object)Utils.localCameraRig.hud) || !Object.op_Implicit((Object)(object)Utils.localCameraRig.hud.healthBar))
			{
				return null;
			}
			Transform transform = ((Component)Utils.localCameraRig.hud.healthBar).transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		private static void SeekerOnEnable(orig_OnEnable orig, SeekerController self)
		{
			orig.Invoke(self);
			try
			{
				object? obj = seekerOverlayControllerField?.GetValue(self);
				OverlayController val = (OverlayController)((obj is OverlayController) ? obj : null);
				if (val == null)
				{
					return;
				}
				val.onInstanceAdded += delegate(OverlayController controller, GameObject instance)
				{
					if (Object.op_Implicit((Object)(object)self.characterBody) && self.characterBody.IsLocalBody())
					{
						Transform transform = instance.transform;
						seekerLotusInstance = (RectTransform)(object)((transform is RectTransform) ? transform : null);
						RoR2Application.onNextUpdate += RepositionSeekerLotus;
					}
				};
			}
			catch (Exception ex)
			{
				VRMod.StaticLogger.LogWarning((object)("[VR Seeker] Failed to hook lotus overlay: " + ex.Message));
			}
		}

		private static void RepositionSeekerLotus()
		{
			//IL_002e: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)seekerLotusInstance))
			{
				return;
			}
			RectTransform localHealthbarTransform = GetLocalHealthbarTransform();
			if (!Object.op_Implicit((Object)(object)localHealthbarTransform))
			{
				return;
			}
			try
			{
				((Transform)seekerLotusInstance).SetParent((Transform)(object)localHealthbarTransform, false);
				((Transform)seekerLotusInstance).localScale = Vector3.one;
				((Transform)seekerLotusInstance).localRotation = Quaternion.identity;
				seekerLotusInstance.anchorMin = new Vector2(0.5f, 1f);
				seekerLotusInstance.anchorMax = new Vector2(0.5f, 1f);
				seekerLotusInstance.pivot = new Vector2(0.5f, 0.5f);
				seekerLotusInstance.anchoredPosition = new Vector2(82f, ModConfig.SeekerLotusRaise.Value);
				Vector3 localPosition = ((Transform)seekerLotusInstance).localPosition;
				localPosition.z = 0f;
				((Transform)seekerLotusInstance).localPosition = localPosition;
				((Transform)seekerLotusInstance).SetAsLastSibling();
				Canvas component = ((Component)seekerLotusInstance).GetComponent<Canvas>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.overrideSorting = false;
				}
				RoR2Application.onNextUpdate += CorrectSeekerLotusPosition;
			}
			catch (Exception arg)
			{
				VRMod.StaticLogger.LogWarning((object)$"[VR Seeker] Lotus reposition failed: {arg}");
			}
		}

		private static void CorrectSeekerLotusPosition()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)seekerLotusInstance))
			{
				((Transform)seekerLotusInstance).localScale = Vector3.one;
				seekerLotusInstance.anchoredPosition = new Vector2(82f, ModConfig.SeekerLotusRaise.Value);
				Vector3 localPosition = ((Transform)seekerLotusInstance).localPosition;
				localPosition.z = 0f;
				((Transform)seekerLotusInstance).localPosition = localPosition;
			}
		}

		private static void SeekerMeditateOnEnter(orig_OnEnter orig, Meditate self)
		{
			orig.Invoke(self);
			try
			{
				object? obj = meditateOverlayControllerField?.GetValue(self);
				OverlayController val = (OverlayController)((obj is OverlayController) ? obj : null);
				if (val == null)
				{
					return;
				}
				val.onInstanceAdded += delegate(OverlayController controller, GameObject instance)
				{
					if (Object.op_Implicit((Object)(object)((EntityState)self).characterBody) && ((EntityState)self).characterBody.IsLocalBody())
					{
						Transform transform = instance.transform;
						seekerMeditateInstance = (RectTransform)(object)((transform is RectTransform) ? transform : null);
						RoR2Application.onNextUpdate += RepositionSeekerMeditate;
					}
				};
			}
			catch (Exception ex)
			{
				VRMod.StaticLogger.LogWarning((object)("[VR Seeker] Failed to hook meditate overlay: " + ex.Message));
			}
		}

		private static void RepositionSeekerMeditate()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)seekerMeditateInstance))
			{
				return;
			}
			RectTransform localHealthbarTransform = GetLocalHealthbarTransform();
			if (!Object.op_Implicit((Object)(object)localHealthbarTransform))
			{
				return;
			}
			try
			{
				Vector3 position = ((Transform)seekerMeditateInstance).position;
				Vector3 lossyScale = ((Transform)seekerMeditateInstance).lossyScale;
				Vector3 lossyScale2 = ((Transform)localHealthbarTransform).lossyScale;
				meditateLocalPos = ((Transform)localHealthbarTransform).InverseTransformPoint(position);
				meditateLocalScale = new Vector3((lossyScale2.x != 0f) ? (lossyScale.x / lossyScale2.x) : 1f, (lossyScale2.y != 0f) ? (lossyScale.y / lossyScale2.y) : 1f, (lossyScale2.z != 0f) ? (lossyScale.z / lossyScale2.z) : 1f);
				if (meditateLocalScale.x < 0.05f || meditateLocalScale.x > 20f)
				{
					meditateLocalScale = Vector3.one;
				}
				ManualLogSource staticLogger = VRMod.StaticLogger;
				object[] obj = new object[5]
				{
					((Object)seekerMeditateInstance).name,
					null,
					null,
					null,
					null
				};
				Transform parent = ((Transform)seekerMeditateInstance).parent;
				obj[1] = ((parent != null) ? ((Object)parent).name : null);
				obj[2] = seekerMeditateInstance.rect;
				obj[3] = meditateLocalPos;
				obj[4] = meditateLocalScale;
				staticLogger.LogInfo((object)string.Format("[VR Seeker] Meditate overlay '{0}' parent='{1}' rect={2} -> localPos={3} localScale={4}", obj));
				((Transform)seekerMeditateInstance).SetParent((Transform)(object)localHealthbarTransform, false);
				((Transform)seekerMeditateInstance).localScale = meditateLocalScale;
				((Transform)seekerMeditateInstance).localRotation = Quaternion.identity;
				ApplyMeditatePosition();
				((Transform)seekerMeditateInstance).SetAsLastSibling();
				Canvas component = ((Component)seekerMeditateInstance).GetComponent<Canvas>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.overrideSorting = false;
				}
				RoR2Application.onNextUpdate += CorrectSeekerMeditatePosition;
			}
			catch (Exception arg)
			{
				VRMod.StaticLogger.LogWarning((object)$"[VR Seeker] Meditate reposition failed: {arg}");
			}
		}

		private static void ApplyMeditatePosition()
		{
			//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_002c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 localPosition = meditateLocalPos;
			localPosition.y += ModConfig.SeekerMeditateRaise.Value;
			localPosition.z = 0f;
			((Transform)seekerMeditateInstance).localPosition = localPosition;
		}

		private static void CorrectSeekerMeditatePosition()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)seekerMeditateInstance))
			{
				((Transform)seekerMeditateInstance).localScale = meditateLocalScale;
				ApplyMeditatePosition();
			}
		}

		private static void SeekerMeditateSetupInputUIIcons(orig_SetupInputUIIcons orig, Meditate self)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			try
			{
				object? obj = meditateChildLocatorField?.GetValue(self);
				ChildLocator val = (ChildLocator)((obj is ChildLocator) ? obj : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				string[] array = meditateArrowChildNames;
				foreach (string text in array)
				{
					Transform val2 = val.FindChild(text);
					if (Object.op_Implicit((Object)(object)val2))
					{
						Quaternion rotation = val2.rotation;
						float z = ((Quaternion)(ref rotation)).eulerAngles.z;
						val2.localRotation = Quaternion.Euler(0f, 0f, z);
					}
				}
			}
			catch (Exception ex)
			{
				VRMod.StaticLogger.LogWarning((object)("[VR Seeker] Arrow rotation fix failed: " + ex.Message));
			}
		}

		private static void HideCrosshair(orig_UpdateCrosshair orig, CrosshairManager self, CharacterBody targetBody, Vector3 crosshairWorldPosition, Camera uiCamera)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self, targetBody, crosshairWorldPosition, uiCamera);
			if (Object.op_Implicit((Object)(object)self.crosshairController) && ((Component)self.crosshairController).gameObject.activeSelf)
			{
				((Component)self.crosshairController).gameObject.SetActive(false);
			}
		}

		private static void ChangeDialogScene(orig_OnActiveSceneChanged orig, Scene oldScene, Scene newScene)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(oldScene, newScene);
			if (((Scene)(ref newScene)).name == "title" && Object.op_Implicit((Object)(object)queuedKickDialog))
			{
				SceneManager.MoveGameObjectToScene(queuedKickDialog, newScene);
			}
		}

		private static void UnparentDialogBoxInternal()
		{
			SimpleDialogBox componentInChildren = ((Component)RoR2Application.instance.mainCanvas).GetComponentInChildren<SimpleDialogBox>();
			if (Object.op_Implicit((Object)(object)componentInChildren))
			{
				componentInChildren.rootObject.transform.SetParent((Transform)null);
				Object.DontDestroyOnLoad((Object)(object)componentInChildren.rootObject);
				queuedKickDialog = componentInChildren.rootObject;
			}
		}

		private static void DestroyPickerPanelCanvas(orig_OnDisplayEnd orig, PickupPickerController self, NetworkUIPromptController networkUIPromptController, LocalUser localUser, CameraRigController cameraRigController)
		{
			orig.Invoke(self, networkUIPromptController, localUser, cameraRigController);
			if (Object.op_Implicit((Object)(object)pickerCanvas))
			{
				Object.Destroy((Object)(object)pickerCanvas);
			}
		}

		private static void MovePickerPanelToWorld(orig_OnDisplayBegin orig, PickupPickerController self, NetworkUIPromptController networkUIPromptController, LocalUser localUser, CameraRigController cameraRigController)
		{
			//IL_0061: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self, networkUIPromptController, localUser, cameraRigController);
			if (Object.op_Implicit((Object)(object)self.panelInstance) && GetUICamera())
			{
				pickerCanvas = Object.Instantiate<GameObject>(pickerCanvasPrefab);
				pickerCanvas.GetComponent<Canvas>().worldCamera = cachedUICam;
				pickerCanvas.transform.rotation = Quaternion.Euler(0f, ((Component)cachedUICam).transform.eulerAngles.y, 0f);
				pickerCanvas.transform.position = pickerCanvas.transform.forward * 4f;
				if (ModConfig.InitialRoomscaleValue)
				{
					pickerCanvas.transform.Translate(0f, 1.8f, 0f);
				}
				Transform transform = self.panelInstance.transform;
				Transform obj = ((transform is RectTransform) ? transform : null);
				obj.SetParent(pickerCanvas.transform);
				obj.localPosition = Vector3.zero;
				obj.localRotation = Quaternion.identity;
				obj.localScale = Vector3.one;
				((RectTransform)obj).offsetMin = Vector2.zero;
				((RectTransform)obj).offsetMax = Vector2.zero;
				TranslucentImage component = self.panelInstance.gameObject.GetComponent<TranslucentImage>();
				if (Object.op_Implicit((Object)(object)component))
				{
					((Behaviour)component).enabled = false;
				}
			}
		}

		internal static void CreateLIVHUD(Camera livCamera)
		{
			CameraRigController localCameraRig = Utils.localCameraRig;
			if (Object.op_Implicit((Object)(object)localCameraRig) && Object.op_Implicit((Object)(object)localCameraRig.hud))
			{
				GameObject obj = Object.Instantiate<GameObject>(Resources.Load<GameObject>("Prefabs/HUDSimple"));
				HUD component = obj.GetComponent<HUD>();
				component.cameraRigController = localCameraRig;
				Canvas component2 = ((Component)component).GetComponent<Canvas>();
				component2.worldCamera = livCamera;
				component2.planeDistance = 1f;
				Object.Destroy((Object)(object)((Component)component).GetComponent<CrosshairManager>());
				component.localUserViewer = localCameraRig.localUserViewer;
				Object.Destroy((Object)(object)((Component)obj.transform.Find("MainContainer/MainUIArea/CrosshairCanvas")).gameObject);
				Object.Destroy((Object)(object)((Component)obj.transform.Find("MainContainer/MainUIArea/Hitmarker")).gameObject);
				int intVal = LayerIndex.triggerZone.intVal;
				obj.SetLayerRecursive(intVal);
				livHUD = component;
			}
		}

		private static void MoveCreditsToWorldSpace(orig_OnEnable orig, CreditsController self)
		{
			//IL_003c: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			if (Object.op_Implicit((Object)(object)creditsCanvasPrefab))
			{
				creditsCanvas = Object.Instantiate<GameObject>(creditsCanvasPrefab, (Transform)null);
				creditsCanvas.transform.position = new Vector3(0f, 0f, 8f);
			}
			if (Object.op_Implicit((Object)(object)creditsCanvas) && Object.op_Implicit((Object)(object)self.creditsPanelController))
			{
				Transform transform = ((Component)self.creditsPanelController.scrollRect).transform;
				transform.SetParent(creditsCanvas.transform);
				transform.localPosition = Vector3.zero;
				transform.localRotation = Quaternion.identity;
				transform.localScale = Vector3.one;
				Object.Destroy((Object)(object)((Component)((Component)self.creditsPanelController).transform.Find("Backdrop")).gameObject);
			}
		}

		private static void SetAddProfileButtonAsDefaultFallback(orig_OpenCreateProfileMenu orig, ProfileMainMenuScreen self, bool firstTime)
		{
			orig.Invoke(self, firstTime);
			self.submitProfileNameButton.defaultFallbackButton = true;
		}

		private static void OpenPopupInMenuCanvas(orig_Awake orig, RemoteGameDetailsPanelController self)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			if (Object.op_Implicit((Object)(object)cachedMultiplayerCanvas))
			{
				((Component)self).transform.SetParent(((Component)cachedMultiplayerCanvas).transform);
			}
			Transform transform = ((Component)self).transform;
			Transform obj = ((transform is RectTransform) ? transform : null);
			obj.localPosition = Vector3.zero;
			obj.rotation = Quaternion.identity;
			obj.localScale = Vector3.one;
			((RectTransform)obj).sizeDelta = gameDetailsResolution;
		}

		private static GameEndReportPanelController UnparentHUD(orig_GenerateReportScreen orig, GameOverController self, HUD hud)
		{
			((Component)hud).transform.SetParent((Transform)null);
			hud.canvas.renderMode = (RenderMode)1;
			return orig.Invoke(self, hud);
		}

		private static bool GetUICamera()
		{
			if ((Object)(object)cachedUICam == (Object)null || !((Behaviour)cachedUICam).isActiveAndEnabled)
			{
				CameraRigController localCameraRig = Utils.localCameraRig;
				if (Object.op_Implicit((Object)(object)localCameraRig))
				{
					cachedUICam = localCameraRig.uiCam;
				}
			}
			return (Object)(object)cachedUICam != (Object)null;
		}

		private static void UpdatePositionsOverride(orig_UpdatePositions orig, UICamera uiCamera)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(uiCamera);
			if (!HUD.cvHudEnable.value || !PositionIndicator.cvPositionIndicatorsEnable.value)
			{
				return;
			}
			foreach (PositionIndicator indicator in PositionIndicator.instancesList)
			{
				Vector3 val = (Object.op_Implicit((Object)(object)indicator.targetTransform) ? indicator.targetTransform.position : indicator.defaultPosition);
				val.y += indicator.yOffset;
				bool flag = PingIndicator.instancesList.Exists((PingIndicator x) => (Object)(object)x.positionIndicator == (Object)(object)indicator);
				Vector3 val2 = ((Component)uiCamera.cameraRigController.sceneCam).transform.parent.InverseTransformPoint(val);
				indicator.transform.position = val2;
				indicator.transform.localScale = (flag ? 1f : 0.2f) * Vector3.Distance(((Component)uiCamera).transform.position, val2) * Vector3.one;
			}
		}

		private static void PositionForUIOverride(orig_PositionForUI orig, Indicator self, Camera sceneCamera, Camera uiCamera)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)self.targetTransform))
			{
				Vector3 position = self.targetTransform.position;
				Vector3 val = ((Component)sceneCamera).transform.parent.InverseTransformPoint(position);
				if ((Object)(object)self.visualizerTransform != (Object)null)
				{
					self.visualizerTransform.position = val;
					Transform visualizerTransform = self.visualizerTransform;
					Vector3 val2 = val - ((Component)uiCamera).transform.position;
					visualizerTransform.rotation = Quaternion.LookRotation(((Vector3)(ref val2)).normalized);
					self.visualizerTransform.localScale = ((self is EngiMissileIndicator) ? 1f : 0.1f) * Vector3.Distance(((Component)sceneCamera).transform.position, position) * Vector3.one;
				}
			}
		}

		private static void CanvasToWorldSpace(GameObject uiObject, Vector2 resolution, Vector3 positionOffset, Vector3 scale, bool addCollider, bool followRotation = false)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Invalid comparison between Unknown and I4
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			if (!GetUICamera())
			{
				return;
			}
			Canvas val = uiObject.GetComponent<Canvas>();
			if (!Object.op_Implicit((Object)(object)val))
			{
				val = uiObject.GetComponentInParent<Canvas>();
				if (!Object.op_Implicit((Object)(object)val))
				{
					VRMod.StaticLogger.LogError((object)("Could not set the render mode of " + ((Object)uiObject).name + " to world space. Make sure a canvas is present on the object or one of its parents."));
					VRMod.StaticLogger.LogError((object)Environment.StackTrace);
					return;
				}
			}
			if ((Object)(object)val == (Object)(object)RoR2Application.instance.mainCanvas)
			{
				VRMod.StaticLogger.LogError((object)"Attempted to set the global main canvas to world space. DO NOT DO THAT!");
				VRMod.StaticLogger.LogError((object)Environment.StackTrace);
				return;
			}
			if ((int)val.renderMode != 2)
			{
				if ((int)val.renderMode == 1)
				{
					val.renderMode = (RenderMode)0;
				}
				val.renderMode = (RenderMode)2;
				val.worldCamera = cachedUICam;
				Vector3 val2 = positionOffset;
				if (followRotation)
				{
					val2 = Quaternion.Euler(camRotation) * val2;
					if ((Object)(object)uiObject.transform.root != (Object)(object)uiObject.transform)
					{
						uiObject.transform.parent.rotation = Quaternion.Euler(uiObject.transform.parent.eulerAngles + camRotation);
					}
					else
					{
						uiObject.transform.rotation = Quaternion.Euler(uiObject.transform.eulerAngles + camRotation);
					}
				}
				if (ModConfig.InitialRoomscaleValue)
				{
					val2.y += 1.8f;
				}
				if (Object.op_Implicit((Object)(object)uiObject.transform.parent))
				{
					uiObject.transform.parent.position = val2;
				}
				uiObject.transform.position = val2;
				uiObject.transform.localScale = scale;
				RectTransform component = uiObject.GetComponent<RectTransform>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.pivot = menuPivot;
					component.sizeDelta = resolution;
				}
			}
			if (addCollider && !Object.op_Implicit((Object)(object)((Component)val).GetComponent<BoxCollider>()))
			{
				Transform transform = ((Component)val).transform;
				RectTransform val3 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				((Component)val).gameObject.AddComponent<BoxCollider>().size = new Vector3(val3.sizeDelta.x, val3.sizeDelta.y, 1f);
			}
		}

		internal static void AdjustHUD(HUD hud)
		{
			//IL_006b: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: 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_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Invalid comparison between Unknown and I4
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: Unknown result type (might be due to invalid IL or missing references)
			//IL_0426: Unknown result type (might be due to invalid IL or missing references)
			//IL_0432: Unknown result type (might be due to invalid IL or missing references)
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0515: Unknown result type (might be due to invalid IL or missing references)
			//IL_053b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0551: Unknown result type (might be due to invalid IL or missing references)
			//IL_055d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0583: Unknown result type (might be due to invalid IL or missing references)
			//IL_0599: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ed: Unknown result type (might be due to invalid IL or missing references)
			if (ModConfig.InitialMotionControlsValue)
			{
				CrosshairManager component = ((Component)hud).GetComponent<CrosshairManager>();
				if (Object.op_Implicit((Object)(object)component))
				{
					((Behaviour)component.hitmarker).enabled = false;
				}
			}
			Transform val = hud.mainContainer.transform.Find("SteamBuildLabel");
			if (Object.op_Implicit((Object)(object)val))
			{
				((Component)val).gameObject.SetActive(false);
			}
			Transform obj = hud.mainUIPanel.transform.Find("SpringCanvas");
			RectTransform val2 = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			val2.anchorMin = ModConfig.AnchorMin;
			val2.anchorMax = ModConfig.AnchorMax;
			Transform obj2 = hud.mainContainer.transform.Find("NotificationArea");
			RectTransform val3 = (RectTransform)(object)((obj2 is RectTransform) ? obj2 : null);
			val3.anchorMin = new Vector2(0.5f, ModConfig.AnchorMin.y);
			val3.anchorMax = new Vector2(0.5f, ModConfig.AnchorMin.y);
			Transform obj3 = hud.mainContainer.transform.Find("MapNameCluster");
			Transform obj4 = ((obj3 is RectTransform) ? obj3 : null);
			((RectTransform)obj4).anchorMin = new Vector2(0.5f, (ModConfig.AnchorMax.y - 0.5f) * 0.54f + 0.5f);
			((RectTransform)obj4).anchorMax = new Vector2(0.5f, (ModConfig.AnchorMax.y - 0.5f) * 0.54f + 0.5f);
			Transform obj5 = ((Transform)val2).Find("ScoreboardPanel");
			RectTransform val4 = (RectTransform)(object)((obj5 is RectTransform) ? obj5 : null);
			val4.offsetMin = new Vector2(0f, val4.offsetMin.y);
			val4.offsetMax = new Vector2(0f, val4.offsetMax.y);
			if (!GetUICamera())
			{
				return;
			}
			hud.canvas.renderMode = (RenderMode)2;
			Transform transform = ((Component)hud).transform;
			Transform obj6 = ((transform is RectTransform) ? transform : null);
			((RectTransform)obj6).sizeDelta = new Vector2((float)ModConfig.HUDWidth.Value, (float)ModConfig.HUDHeight.Value);
			obj6.localScale = menuScale;
			obj6.SetParent(((Component)cachedUICam).transform);
			obj6.localRotation = Quaternion.identity;
			obj6.localPosition = new Vector3(0f, 0f, 12.35f);
			((RectTransform)obj6).pivot = menuPivot;
			if (ModConfig.UseSmoothHUD.Value)
			{
				hud.mainContainer.AddComponent<SmoothHUD>().Init(((Component)hud.cameraRigController.uiCam).transform);
			}
			if ((int)SceneCatalog.mostRecentSceneDef.sceneType == 3)
			{
				return;
			}
			if (ModConfig.TempWristHUDValue)
			{
				Transform obj7 = ((Transform)val2).Find("BottomLeftCluster/BarRoots");
				RectTransform val5 = (RectTransform)(object)((obj7 is RectTransform) ? obj7 : null);
				val5.pivot = new Vector2(0.5f, 0f);
				if (ModConfig.BetterHealthBar.Value)
				{
					((Transform)val5).SetParent((Transform)(object)val2);
					((Transform)val5).localRotation = Quaternion.identity;
					val5.offsetMin = new Vector2(300f, val5.offsetMin.y);
					val5.offsetMax = new Vector2(-300f, val5.offsetMax.y);
					Vector3 localPosition = ((Transform)val3).localPosition;
					localPosition.y += 80f;
					((Transform)val3).localPosition = localPosition;
					Transform obj8 = ((Transform)val2).Find("BottomCenterCluster/SpectatorLabel");
					Transform obj9 = ((obj8 is RectTransform) ? obj8 : null);
					Vector3 localPosition2 = obj9.localPosition;
					localPosition2.y += 68f;
					obj9.localPosition = localPosition2;
				}
				else
				{
					((Transform)val5).localRotation = Quaternion.identity;
					((Transform)val5).localPosition = Vector3.zero;
					MotionControls.AddWristHUD(left: true, val5);
				}
				Transform obj10 = ((Transform)val2).Find("UpperLeftCluster");
				RectTransform val6 = (RectTransform)(object)((obj10 is RectTransform) ? obj10 : null);
				((Transform)val6).localRotation = Quaternion.identity;
				val6.pivot = new Vector2(0.5f, 1f);
				((Transform)val6).localPosition = Vector3.zero;
				MotionControls.AddWristHUD(left: true, val6);
				Transform obj11 = ((Transform)val2).Find("RightCluster");
				RectTransform val7 = (RectTransform)(object)((obj11 is RectTransform) ? obj11 : null);
				((Transform)val7).localRotation = Quaternion.identity;
				val7.pivot = new Vector2(0f, 0f);
				((Transform)val7).localPosition = Vector3.zero;
				Transform child = ((Transform)val7).GetChild(0);
				((RectTransform)((child is RectTransform) ? child : null)).pivot = new Vector2(0f, 2f);
				MotionControls.AddWristHUD(left: false, val7);
				Transform obj12 = ((Transform)val2).Find("BottomRightCluster");
				RectTransform val8 = (RectTransform)(object)((obj12 is RectTransform) ? obj12 : null);
				((Transform)val8).localRotation = Quaternion.identity;
				val8.pivot = new Vector2(0.2f, -0.6f);
				((Transform)val8).localPosition = Vector3.zero;
				MotionControls.AddWristHUD(left: false, val8);
				MotionControls.SetSprintIcon(((Component)((Transform)val8).Find("Scaler/SprintCluster/SprintIcon")).GetComponent<Image>());
			}
			if (!ModConfig.TempWatchHUDValue)
			{
				return;
			}
			Transform val9 = ((Transform)val2).Find("TopCenterCluster");
			GameObject val10 = Object.Instantiate<GameObject>(((Component)val9).gameObject, val9.parent);
			foreach (Transform item in val10.transform)
			{
				Object.Destroy((Object)(object)((Component)item).gameObject);
			}
			Transform transform2 = val10.transform;
			RectTransform val11 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
			val11.pivot = new Vector2(0.5f, 1f);
			((Transform)val11).localPosition = Vector3.zero;
			Transform obj13 = val9.Find("ItemInventoryDisplayRoot");
			Transform obj14 = ((obj13 is RectTransform) ? obj13 : null);
			obj14.SetParent((Transform)(object)val11);
			obj14.localPosition = Vector3.zero;
			MotionControls.AddWatchHUD(left: true, val11);
			Transform obj15 = ((Transform)val2).Find("BottomLeftCluster/ChatBoxRoot");
			RectTransform val12 = (RectTransform)(object)((obj15 is RectTransform) ? obj15 : null);
			((Transform)val12).localRotation = Quaternion.identity;
			val12.pivot = new Vector2(0.5f, 0f);
			((Transform)val12).localPosition = Vector3.zero;
			MotionControls.AddWatchHUD(left: true, val12);
			Transform obj16 = ((Transform)val2).Find("UpperRightCluster");
			RectTransform val13 = (RectTransform)(object)((obj16 is RectTransform) ? obj16 : null);
			((Transform)val13).localRotation = Quaternion.identity;
			val13.pivot = new Vector2(-1f, -2.5f);
			((Transform)val13).localPosition = Vector3.zero;
			MotionControls.AddWatchHUD(left: false, val13);
			Transform obj17 = ((Transform)val2).Find("LeftCluster");
			RectTransform val14 = (RectTransform)(object)((obj17 is RectTransform) ? obj17 : null);
			((Transform)val14).localRotation = Quaternion.identity;
			val14.pivot = new Vector2(1f, 0.5f);
			((Transform)val14).localPosition = Vector3.zero;
			MotionControls.AddWatchHUD(left: false, val14);
		}

		private static void UpdateAllHealthBarPositionsVR(orig_UpdateAllHealthbarPositions orig, CombatHealthBarViewer self, Camera sceneCam, Camera uiCam)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: 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)
			if (!Object.op_Implicit((Object)(object)sceneCam) || !Object.op_Implicit((Object)(object)uiCam))
			{
				return;
			}
			foreach (HealthBarInfo value in self.victimToHealthBarInfo.Values)
			{
				Vector3 position = value.sourceTransform.position;
				position.y += value.verticalOffset;
				Vector3 val = ((Component)sceneCam).transform.parent.InverseTransformPoint(position);
				value.healthBarRootObjectTransform.position = val;
				value.healthBarRootObjectTransform.localScale = 0.1f * Vector3.Distance(((Component)uiCam).transform.position, val) * Vector3.one;
			}
		}
	}
	internal class UIPointer
	{
		private static Camera _cachedUICam;

		private static float clickTime;

		private static Vector3 clickPosition;

		private static Vector3 pointerHitPosition;

		private static GameObject cursorPrefab;

		private static GameObject cursorInstance;

		private static Canvas lastHitCanvas;

		private static Camera cachedUICam
		{
			get
			{
				if (((Object)(object)_cachedUICam == (Object)null || !((Behaviour)_cachedUICam).isActiveAndEnabled) && Object.op_Implicit((Object)(object)Camera.main))
				{
					SceneCamera component = ((Component)Camera.main).GetComponent<SceneCamera>();
					if (Object.op_Implicit((Object)(object)component))
					{
						_cachedUICam = component.cameraRigController.uiCam;
					}
				}
				return _cachedUICam;
			}
		}

		internal static void Init()
		{
			cursorPrefab = VRMod.VRAssetBundle.LoadAsset<GameObject>("UICursor");
		}

		private static void PlaceTooltipOnCursor(orig_LateUpdate orig, TooltipController self)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)cursorInstance))
			{
				((Transform)self.tooltipCenterTransform).position = cursorInstance.transform.position;
			}
		}

		private static void MatchTooltipToCanvas(orig_SetTooltip orig, MPEventSystem eventSystem, TooltipProvider newTooltipProvider, Vector2 tooltipPosition, RectTransform rectTransformToDisplayAt)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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_00c0: 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)
			orig.Invoke(eventSystem, newTooltipProvider, tooltipPosition, rectTransformToDisplayAt);
			if (Object.op_Implicit((Object)(object)eventSystem.currentTooltip) && Object.op_Implicit((Object)(object)lastHitCanvas))
			{
				if (Object.op_Implicit((Object)(object)cursorInstance))
				{
					Vector3 val = ((Component)lastHitCanvas).transform.InverseTransformPoint(cursorInstance.transform.position);
					Vector2 val2 = default(Vector2);
					((Vector2)(ref val2))..ctor(0f, 0f);
					val2.x = ((val.x > 0f) ? 1f : 0f);
					val2.y = ((val.y > 0f) ? 1f : 0f);
					eventSystem.currentTooltip.tooltipFlipTransform.anchorMin = val2;
					eventSystem.currentTooltip.tooltipFlipTransform.anchorMax = val2;
					eventSystem.currentTooltip.tooltipFlipTransform.pivot = val2;
				}
				Canvas component = ((Component)eventSystem.currentTooltip).GetComponent<Canvas>();
				component.renderMode = (RenderMode)2;
				Transform transform = ((Component)component).transform;
				Transform obj = ((transform is RectTransform) ? transform : null);
				Transform transform2 = ((Component)lastHitCanvas).transform;
				RectTransform val3 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
				((RectTransform)obj).sizeDelta = val3.sizeDelta;
				((RectTransform)obj).pivot = val3.pivot;
				obj.position = ((Transform)val3).position;
				obj.rotation = ((Transform)val3).rotation;
				obj.localScale = ((Transform)val3).localScale;
			}
		}

		private static void EditPointerPosition(orig_Update orig, MPInput self)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Invalid comparison between Unknown and I4
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//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_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)cachedUICam) || !Utils.isUsingUI || Utils.localInputPlayer == null || Utils.localInputPlayer.controllers.GetLastActiveController() == null || (int)Utils.localInputPlayer.controllers.GetLastActiveController().type == 2)
			{
				if (Object.op_Implicit((Object)(object)cursorInstance) && cursorInstance.activeSelf)
				{
					cursorInstance.SetActive(false);
				}
				orig.Invoke(self);
				return;
			}
			if (!Object.op_Implicit((Object)(object)cursorInstance) && Object.op_Implicit((Object)(object)cursorPrefab))
			{
				cursorInstance = Object.Instantiate<GameObject>(cursorPrefab);
			}
			self.internalScreenPositionDelta = Vector2.zero;
			self._scrollDelta = new Vector2(0f, self.player.GetAxis(26));
			if (((BaseInput)self).GetMouseButtonDown(0))
			{
				clickTime = Time.realtimeSinceStartup;
				clickPosition = pointerHitPosition;
			}
			else if (((BaseInput)self).GetMouseButtonUp(0))
			{
				clickTime = 0f;
			}
			Camera val = cachedUICam;
			Ray uiRay = default(Ray);
			if (MotionControls.HandsReady)
			{
				uiRay = MotionControls.GetHandByDominance(dominant: true).uiRay;
			}
			else
			{
				((Ray)(ref uiRay))..ctor(((Component)val).transform.position, ((Component)val).transform.forward);
			}
			Ray val2 = uiRay;
			LayerIndex ui = LayerIndex.ui;
			RaycastHit val3 = default(RaycastHit);
			if (Physics.Raycast(val2, ref val3, 100f, LayerMask.op_Implicit(((LayerIndex)(ref ui)).mask)))
			{
				pointerHitPosition = ((RaycastHit)(ref val3)).point;
				if (Object.op_Implicit((Object)(object)cursorInstance))
				{
					if (!cursorInstance.activeSelf)
					{
						cursorInstance.SetActive(true);
					}
					cursorInstance.transform.position = pointerHitPosition;
					cursorInstance.transform.rotation = Quaternion.LookRotation(((RaycastHit)(ref val3)).normal, Vector3.up);
				}
				lastHitCanvas = ((Component)((RaycastHit)(ref val3)).collider).GetComponent<Canvas>();
			}
			else if (cursorInstance.activeSelf)
			{
				cursorInstance.SetActive(false);
			}
			Vector3 val4 = val.WorldToScreenPoint(pointerHitPosition);
			if (!(Time.realtimeSinceStartup - clickTime > 0.25f))
			{
				Vector3 val5 = pointerHitPosition - clickPosition;
				if (!(((Vector3)(ref val5)).magnitude > 1f))
				{
					return;
				}
			}
			self.internalMousePosition = Vector2.op_Implicit(val4);
		}
	}
	[BepInPlugin("com.DrBibop.VRMod", "Resurrected VRMod", "1.0.3")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class VRMod : BaseUnityPlugin
	{
		internal static ManualLogSource StaticLogger;

		internal static AssetBundle VRAssetBundle;

		private static XRManagerSettings activeManagerSettings;

		private static bool xrShutDown;

		private void Awake()
		{
			StaticLogger = ((BaseUnityPlugin)this).Logger;
			VRAssetBundle = AssetBundle.LoadFromMemory(Resources.vrmodassets);
			ModConfig.Init();
			ActionAddons.Init();
			SettingsAddon.Init();
			UIFixes.Init();
			ChestHighlighter.Init();
			ItemHints.Init();
			MenuSubmitGuard.Init();
			LobbyNavigation.Init();
			CameraFixes.Init();
			CutsceneFixes.Init();
			FocusChecker.Init();
			if (ModConfig.InitialMotionControlsValue)
			{
				RoR2Application.isModded = true;
				MotionControls.Init();
				MotionControlledAbilities.Init();
				RuntimeHands.Init();
				EntityStateAnimationParameter.Init();
			}
			RoR2Application.onLoad = (Action)Delegate.Combine(RoR2Application.onLoad, (Action)delegate
			{
				InitVR();
				RecenterController.Init();
				UIPointer.Init();
				try
				{
					HapticsManager.Init();
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)("[VRMod] Haptics init failed (missing library?): " + ex.Message));
				}
				RoR2Application.onNextUpdate += InitControllers;
			});
		}

		private void InitControllers()
		{
			Controllers.Init();
			ControllerGlyphs.Init();
		}

		private void InitVR()
		{
			XRManagerSettings val = (ScriptableObject.CreateInstance<XRGeneralSettings>().Manager = ScriptableObject.CreateInstance<XRManagerSettings>());
			((List<XRLoader>)val.activeLoaders).Clear();
			XRLoader item = (XRLoader)(object)ScriptableObject.CreateInstance<OpenXRLoader>();
			OpenXRSettings.Instance.renderMode = (RenderMode)0;
			SetupControllerProfiles();
			val.m_Loaders.Add(item);
			val.InitializeLoaderSync();
			if ((Object)(object)val.activeLoader == (Object)null)
			{
				StaticLogger.LogError((object)"Failed to initialize OpenXR Loader. Is the VR headset ready?");
				return;
			}
			val.StartSubsystems();
			activeManagerSettings = val;
			Application.quitting += ShutdownXR;
			List<XRDisplaySubsystem> list = new List<XRDisplaySubsystem>();
			SubsystemManager.GetInstances<XRDisplaySubsystem>(list);
			bool flag = list.Exists((XRDisplaySubsystem d) => ((IntegratedSubsystem)d).running);
			List<XRInputSubsystem> list2 = new List<XRInputSubsystem>();
			SubsystemManager.GetInstances<XRInputSubsystem>(list2);
			foreach (XRInputSubsystem item2 in list2)
			{
				item2.TrySetTrackingOriginMode((TrackingOriginModeFlags)1);
			}
			if (!flag)
			{
				StaticLogger.LogInfo((object)"InitVR: XR display subsystem not running yet (it usually starts a moment later). If the headset stays black, check that the OpenXR runtime is active.");
			}
			StaticLogger.LogInfo((object)$"InitVR: OpenXR display running={flag}, {list2.Count} XR input subsystem(s).");
			StaticLogger.LogInfo((object)$"[VR config] SeatedMode(config)={ModConfig.SeatedMode.Value} -> forcing device origin + eye level; ControllerAngleOffset={ModConfig.ControllerAngleOffset.Value}; IntroCameraYaw={ModConfig.IntroCameraYaw.Value}; MotionControls={ModConfig.InitialMotionControlsValue}; FirstPerson={ModConfig.InitialFirstPersonValue}");
			VRInputDiagnostics.LogInteractionProfiles("after InitVR");
		}

		private static void ShutdownXR()
		{
			if (xrShutDown)
			{
				return;
			}
			xrShutDown = true;
			try
			{
				if ((Object)(object)activeManagerSettings != (Object)null && (Object)(object)activeManagerSettings.activeLoader != (Object)null)
				{
					StaticLogger.LogInfo((object)"[VR shutdown] Stopping OpenXR subsystems.");
					activeManagerSettings.StopSubsystems();
					StaticLogger.LogInfo((object)"[VR shutdown] Deinitialising the OpenXR loader.");
					activeManagerSettings.DeinitializeLoader();
					StaticLogger.LogInfo((object)"[VR shutdown] OpenXR loader deinitialised.");
				}
			}
			catch (Exception ex)
			{
				StaticLogger.LogWarning((object)("[VR shutdown] " + ex.Message));
			}
			finally
			{
				StaticLogger.LogInfo((object)"[VR shutdown] Ending process.");
				FlushBepInExLog();
				try
				{
					Process.GetCurrentProcess().Kill();
				}
				catch (Exception ex2)
				{
					StaticLogger.LogWarning((object)("[VR shutdown] Kill failed: " + ex2.Message));
				}
			}
		}

		private static void FlushBepInExLog()
		{
			try
			{
				foreach (ILogListener listener in Logger.Listeners)
				{
					DiskLogListener val = (DiskLogListener)(object)((listener is DiskLogListener) ? listener : null);
					if (val != null && val.LogWriter != null)
					{
						val.LogWriter.Flush();
					}
				}
			}
			catch
			{
			}
		}

		private void SetupControllerProfiles()
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			StaticLogger.LogInfo((object)"SetupControllerProfiles: Setting up OpenXR controller profiles...");
			try
			{
				OpenXRSettings instance = OpenXRSettings.Instance;
				if (instance.features.Length != 0)
				{
					StaticLogger.LogInfo((object)$"SetupControllerProfiles: Features already configured ({instance.features.Length} features)");
					return;
				}
				List<OpenXRFeature> list = new List<OpenXRFeature>();
				Type[] array = new Type[7]
				{
					typeof(OculusTouchControllerProfile),
					typeof(MetaQuestTouchProControllerProfile),
					typeof(ValveIndexControllerProfile),
					typeof(HTCViveControllerProfile),
					typeof(HPReverbG2ControllerProfile),
					typeof(MicrosoftMotionControllerProfile),
					typeof(KHRSimpleControllerProfile)
				};
				foreach (Type type in array)
				{
					try
					{
						OpenXRFeature val = (OpenXRFeature)ScriptableObject.CreateInstance(type);
						val.enabled = true;
						list.Add(val);
						StaticLogger.LogInfo((object)("  Created profile: " + type.Name));
					}
					catch (Exception ex)
					{
						StaticLogger.LogWarning((object)("  Failed to create " + type.Name + ": " + ex.Message));
					}
				}
				if (list.Count > 0)
				{
					instance.features = list.ToArray();
					StaticLogger.LogInfo((object)$"SetupControllerProfiles: Added {list.Count} controller profiles");
				}
				else
				{
					StaticLogger.LogWarning((object)"SetupControllerProfiles: No controller profiles could be created");
				}
			}
			catch (Exception arg)
			{
				StaticLogger.LogError((object)$"SetupControllerProfiles failed: {arg}");
			}
		}
	}
}
namespace VRMod.Properties
{
	internal static class Resources
	{
		private static byte[] _vrmodassets;

		internal static byte[] vrmodassets => _vrmodassets ?? (_vrmodassets = Load("VRMod.Properties.vrmodassets"));

		private static byte[] Load(string name)
		{
			using Stream stream = typeof(Resources).Assembly.GetManifestResourceStream(name);
			if (stream == null)
			{
				throw new FileNotFoundException("Embedded resource not found: " + name);
			}
			using MemoryStream memoryStream = new MemoryStream();
			stream.CopyTo(memoryStream);
			return memoryStream.ToArray();
		}
	}
}
namespace VRMod.Inputs
{
	internal abstract class BaseInput
	{
		internal XRNode xrNode;

		protected InputDevice device;

		internal BaseInput(XRNode deviceNode)
		{
			//IL_0007: 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)
			xrNode = deviceNode;
		}

		protected bool CheckDevice()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (!((InputDevice)(ref device)).isValid)
			{
				device = InputDevices.GetDeviceAtXRNode(xrNode);
				return ((InputDevice)(ref device)).isValid;
			}
			return true;
		}

		internal abstract void UpdateValues(CustomController vrControllers);
	}
	internal class ButtonInput : BaseInput
	{
		protected InputHelpers.Button button;

		protected int buttonID;

		internal int ElementId => buttonID;

		internal ButtonInput(XRNode deviceNode, InputHelpers.Button button, int buttonID)
			: base(deviceNode)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			this.button = button;
			this.buttonID = buttonID;
		}

		protected bool PollButtonState()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (device.IsPressed(button, out var isPressed))
			{
				return isPressed;
			}
			return false;
		}

		internal override void UpdateValues(CustomController vrController)
		{
			if (CheckDevice())
			{
				vrController.SetButtonValueById(buttonID, PollButtonState());
			}
		}
	}
	internal class HoldableButtonInput : ButtonInput
	{
		private float holdablePressTime;

		private bool prevHoldableValue;

		internal HoldableButtonInput(XRNode deviceNode, InputHelpers.Button button, int buttonID)
			: base(deviceNode, button, buttonID)
		{
		}//IL_0001: Unknown result type (might be due to invalid IL or missing references)


		internal override void UpdateValues(CustomController vrController)
		{
			if (CheckDevice())
			{
				bool flag = PollButtonState();
				if (flag && !prevHoldableValue)
				{
					holdablePressTime = Time.realtimeSinceStartup;
				}
				vrController.SetButtonValueById(buttonID, flag && Time.realtimeSinceStartup - holdablePressTime > 0.4f);
				prevHoldableValue = flag;
			}
		}
	}
	internal class ReleaseButtonInput : ButtonInput
	{
		private bool canRelease;

		private bool prevState;

		private float pressTime;

		internal ReleaseButtonInput(XRNode deviceNode, InputHelpers.Button button, int buttonID)
			: base(deviceNode, button, buttonID)
		{
		}//IL_0001: Unknown result type (might be due to invalid IL or missing references)


		internal override void UpdateValues(CustomController vrController)
		{
			if (!CheckDevice())
			{
				return;
			}
			bool flag = false;
			bool flag2 = PollButtonState();
			if (flag2)
			{
				if (!prevState)
				{
					pressTime = Time.realtimeSinceStartup;
				}
				canRelease = Time.realtimeSinceStartup - pressTime < 0.4f;
			}
			else
			{
				flag = canRelease && Time.realtimeSinceStartup - pressTime < 0.1f;
			}
			vrController.SetButtonValueById(buttonID, flag);
			prevState = flag2;
		}
	}
	internal class SimulatedVectorInput : VectorInput
	{
		private InputHelpers.Button upButton;

		private InputHelpers.Button rightButton;

		private InputHelpers.Button downButton;

		private InputHelpers.Button leftButton;

		internal SimulatedVectorInput(XRNode deviceNode, InputHelpers.Axis2D vector, int xAxisID, int yAxisID, InputHelpers.Button upButton, InputHelpers.Button rightButton, InputHelpers.Button downButton, InputHelpers.Button leftButton)
			: base(deviceNode, vector, xAxisID, yAxisID)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			this.upButton = upButton;
			this.rightButton = rightButton;
			this.downButton = downButton;
			this.leftButton = leftButton;
		}

		internal override void UpdateValues(CustomController vrController)
		{
			//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_0019: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			if (CheckDevice())
			{
				Vector2 val = PollVector();
				bool isPressed = default(bool);
				if (upButton != InputHelpers.Button.None && device.IsPressed(upButton, out isPressed) && isPressed)
				{
					val.y += 1f;
				}
				bool isPressed2 = default(bool);
				if (rightButton != InputHelpers.Button.None && device.IsPressed(rightButton, out isPressed2) && isPressed2)
				{
					val.x += 1f;
				}
				bool isPressed3 = default(bool);
				if (downButton != InputHelpers.Button.None && device.IsPressed(downButton, out isPressed3) && isPressed3)
				{
					val.y -= 1f;
				}
				bool isPressed4 = default(bool);
				if (leftButton != InputHelpers.Button.None && device.IsPressed(leftButton, out isPressed4) && isPressed4)
				{
					val.x -= 1f;
				}
				val.x = Mathf.Clamp(val.x, -1f, 1f);
				val.y = Mathf.Clamp(val.y, -1f, 1f);
				vrController.SetAxisValueById(xAxisID, val.x);
				vrController.SetAxisValueById(yAxisID, val.y);
			}
		}
	}
	internal class VectorInput : BaseInput
	{
		protected InputHelpers.Axis2D vector;

		protected int xAxisID;

		protected int yAxisID;

		internal VectorInput(XRNode deviceNode, InputHelpers.Axis2D vector, int xAxisID, int yAxisID)
			: base(deviceNode)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			this.vector = vector;
			this.xAxisID = xAxisID;
			this.yAxisID = yAxisID;
		}

		protected Vector2 PollVector()
		{
			//IL_0001: 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_0015: Unknown result type (might be due to invalid IL or missing references)
			if (device.TryReadAxis2DValue(vector, out var value))
			{
				return value;
			}
			return Vector2.zero;
		}

		internal override void UpdateValues(CustomController vrController)
		{
			//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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (CheckDevice())
			{
				Vector2 val = PollVector();
				vrController.SetAxisValueById(xAxisID, val.x);
				vrController.SetAxisValueById(yAxisID, val.y);
			}
		}
	}
	internal static class VRInputDiagnostics
	{
		private static float nextDeviceScanTime;

		private static bool loggedDevicesPresent;

		private static bool loggedNoDevicesWarning;

		private static bool loggedFirstButtonActivity;

		private static bool loggedControllerAdded;

		private static int frameCount;

		internal static void LogInteractionProfiles(string context)
		{
			try
			{
				OpenXRSettings instance = OpenXRSettings.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					VRMod.StaticLogger.LogWarning((object)("[VR input] " + context + ": OpenXRSettings.Instance is null."));
					return;
				}
				try
				{
					VRMod.StaticLogger.LogInfo((object)("[VR input] OpenXR runtime: '" + OpenXRRuntime.name + "' version " + OpenXRRuntime.version + " (OpenXR API " + OpenXRRuntime.apiVersion + ", plugin " + OpenXRRuntime.pluginVersion + ")."));
				}
				catch (Exception ex)
				{
					VRMod.StaticLogger.LogWarning((object)("[VR input] Could not read the OpenXR runtime name: " + ex.Message));
				}
				OpenXRFeature[] features = instance.features;
				int num = ((features != null) ? features.Length : 0);
				VRMod.StaticLogger.LogInfo((object)$"[VR input] {context}: {num} OpenXR feature(s) registered.");
				if (features == null)
				{
					return;
				}
				OpenXRFeature[] array = features;
				foreach (OpenXRFeature val in array)
				{
					if (!((Object)(object)val == (Object)null))
					{
						VRMod.StaticLogger.LogInfo((object)$"[VR input]   feature '{((object)val).GetType().Name}' enabled={val.enabled}");
					}
				}
			}
			catch (Exception ex2)
			{
				VRMod.StaticLogger.LogWarning((object)("[VR input] LogInteractionProfiles failed: " + ex2.Message));
			}
		}

		internal static void DumpDevices(string context)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				List<InputDevice> list = new List<InputDevice>();
				InputDevices.GetDevices(list);
				if (list.Count == 0)
				{
					VRMod.StaticLogger.LogWarning((object)("[VR input] " + context + ": no XR input devices reported by the runtime yet."));
					return;
				}
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine($"[VR input] {context}: {list.Count} XR device(s):");
				foreach (InputDevice item in list)
				{
					InputDevice current = item;
					stringBuilder.AppendLine($"    '{((InputDevice)(ref current)).name}' valid={((InputDevice)(ref current)).isValid} characteristics=({((InputDevice)(ref current)).characteristics})");
				}
				InputDevice deviceAtXRNode = InputDevices.GetDeviceAtXRNode((XRNode)4);
				InputDevice deviceAtXRNode2 = InputDevices.GetDeviceAtXRNode((XRNode)5);
				stringBuilder.AppendLine($"    LeftHand node valid={((InputDevice)(ref deviceAtXRNode)).isValid} name='{((InputDevice)(ref deviceAtXRNode)).name}'");
				stringBuilder.AppendLine($"    RightHand node valid={((InputDevice)(ref deviceAtXRNode2)).isValid} name='{((InputDevice)(ref deviceAtXRNode2)).name}'");
				VRMod.StaticLogger.LogInfo((object)stringBuilder.ToString());
			}
			catch (Exception ex)
			{
				VRMod.StaticLogger.LogWarning((object)("[VR input] DumpDevices failed: " + ex.Message));
			}
		}

		internal static void OnControllerAddedToPlayer(string playerName)
		{
			if (!loggedControllerAdded)
			{
				loggedControllerAdded = true;
				VRMod.StaticLogger.LogInfo((object)("[VR input] VR Rewired controller attached to player '" + playerName + "'. Maps should now be live."));
			}
		}

		internal static void Tick(IEnumerable<BaseInput> inputs)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_00db: 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)
			try
			{
				frameCount++;
				float unscaledTime = Time.unscaledTime;
				if (unscaledTime >= nextDeviceScanTime)
				{
					nextDeviceScanTime = unscaledTime + 1f;
					InputDevice deviceAtXRNode = InputDevices.GetDeviceAtXRNode((XRNode)4);
					InputDevice deviceAtXRNode2 = InputDevices.GetDeviceAtXRNode((XRNode)5);
					int num;
					if (((InputDevice)(ref deviceAtXRNode)).isValid)
					{
						num = (((InputDevice)(ref deviceAtXRNode2)).isValid ? 1 : 0);
						if (num != 0 && !loggedDevicesPresent)
						{
							loggedDevicesPresent = true;
							VRMod.StaticLogger.LogInfo((object)"[VR input] Both hand controllers are now visible to the legacy XR input system. If menu input still does nothing, the break is downstream (Rewired maps / action IDs).");
						}
					}
					else
					{
						num = 0;
					}
					if (num == 0 && !loggedNoDevicesWarning && unscaledTime > 10f)
					{
						loggedNoDevicesWarning = true;
						VRMod.StaticLogger.LogWarning((object)("[VR input] After 10s the runtime still reports no controller at one or both hand nodes " + $"(left valid={((InputDevice)(ref deviceAtXRNode)).isValid}, right valid={((InputDevice)(ref deviceAtXRNode2)).isValid}). This usually means the OpenXR interaction " + "profiles did not register, so no controller input can reach the game. Check the 'SetupControllerProfiles' lines earlier in this log."));
						DumpDevices("no-device timeout");
					}
				}
				if (!loggedFirstButtonActivity && inputs != null)
				{
					InputDevice deviceAtXRNode3 = InputDevices.GetDeviceAtXRNode((XRNode)4);
					InputDevice deviceAtXRNode4 = InputDevices.GetDeviceAtXRNode((XRNode)5);
					if (AnyActivity(deviceAtXRNode3) || AnyActivity(deviceAtXRNode4))
					{
						loggedFirstButtonActivity = true;
						VRMod.StaticLogger.LogInfo((object)"[VR input] First controller button/stick activity detected - the XR read path is working. If the game still does not respond, the Rewired action IDs no longer match this build of the game.");
					}
				}
			}
			catch (Exception ex)
			{
				if (frameCount < 5)
				{
					VRMod.StaticLogger.LogWarning((object)("[VR input] diagnostics tick failed: " + ex.Message));
				}
			}
		}

		private static bool AnyActivity(InputDevice device)
		{
			//IL_000d: 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_0035: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			if (!((InputDevice)(ref device)).isValid)
			{
				return false;
			}
			bool flag = default(bool);
			if (((InputDevice)(ref device)).TryGetFeatureValue(CommonUsages.primaryButton, ref flag) && flag)
			{
				return true;
			}
			bool flag2 = default(bool);
			if (((InputDevice)(ref device)).TryGetFeatureValue(CommonUsages.secondaryButton, ref flag2) && flag2)
			{
				return true;
			}
			bool flag3 = default(bool);
			if (((InputDevice)(ref device)).TryGetFeatureValue(CommonUsages.triggerButton, ref flag3) && flag3)
			{
				return true;
			}
			bool flag4 = default(bool);
			if (((InputDevice)(ref device)).TryGetFeatureValue(CommonUsages.gripButton, ref flag4) && flag4)
			{
				return true;
			}
			bool flag5 = default(bool);
			if (((InputDevice)(ref device)).TryGetFeatureValue(CommonUsages.primary2DAxisClick, ref flag5) && flag5)
			{
				return true;
			}
			Vector2 val = default(Vector2);
			if (((InputDevice)(ref device)).TryGetFeatureValue(CommonUsages.primary2DAxis, ref val) && ((Vector2)(ref val)).sqrMagnitude > 0.25f)
			{
				return true;
			}
			return false;
		}
	}
}
namespace VRMod.Inputs.Legacy
{
	internal class LegacyAxisInput : LegacyInput
	{
		private bool invert;

		internal LegacyAxisInput(bool leftController, int inputIndex, bool invert, params int[] inputIDs)
			: base(leftController, inputIndex, inputIDs)
		{
			this.invert = invert;
		}

		internal override void UpdateValues(CustomController vrControllers)
		{
			float num = UnityInputHelper.GetJoystickAxisRawValueByJoystickIndex(base.joystickID, inputIndex);
			if (invert)
			{
				num = 0f - num;
			}
			int[] array = inputIDs;
			foreach (int num2 in array)
			{
				vrControllers.SetAxisValueById(num2, num);
			}
		}
	}
	internal class LegacyAxisToButtonInput : LegacyButtonInput
	{
		internal LegacyAxisToButtonInput(bool leftController, int inputIndex, params int[] inputIDs)
			: base(leftController, inputIndex, inputIDs)
		{
		}

		internal override void UpdateValues(CustomController vrControllers)
		{
			bool flag = UnityInputHelper.GetJoystickAxisRawValueByJoystickIndex(base.joystickID, inputIndex) > 0.7f;
			if (flag)
			{
				int[] array = inputIDs;
				foreach (int num in array)
				{
					vrControllers.SetButtonValueById(num, flag);
				}
			}
		}
	}
	internal class LegacyButtonInput : LegacyInput
	{
		internal LegacyButtonInput(bool leftController, int inputIndex, params int[] inputIDs)
			: base(leftController, inputIndex, inputIDs)
		{
		}

		internal override void UpdateValues(CustomController vrControllers)
		{
			bool joystickButtonValueByJoystickIndex = UnityInputHelper.GetJoystickButtonValueByJoystickIndex(base.joystickID, inputIndex);
			if (joystickButtonValueByJoystickIndex)
			{
				int[] array = inputIDs;
				foreach (int num in array)
				{
					vrControllers.SetButtonValueById(num, joystickButtonValueByJoystickIndex);
				}
			}
		}
	}
	internal class LegacyInput : BaseInput
	{
		private bool leftController;

		protected int inputIndex;

		protected int[] inputIDs;

		protected int joystickID
		{
			get
			{
				if (!leftController)
				{
					return Controllers.rightJoystickID;
				}
				return Controllers.leftJoystickID;
			}
		}

		internal LegacyInput(bool leftController, int inputIndex, params int[] inputIDs)
			: base((XRNode)2)
		{
			this.leftController = leftController;
			this.inputIndex = inputIndex;
			this.inputIDs = inputIDs;
		}

		internal override void UpdateValues(CustomController vrControllers)
		{
		}
	}
	internal class LegacyNormalAndReleaseButtonInput : LegacyInput
	{
		private float lastChangeTime;

		private bool lastState;

		private bool canRelease;

		internal LegacyNormalAndReleaseButtonInput(bool leftController, int inputIndex, params int[] inputIDs)
			: base(leftController, inputIndex, inputIDs)
		{
		}

		internal override void UpdateValues(CustomController vrControllers)
		{
			bool joystickButtonValueByJoystickIndex = UnityInputHelper.GetJoystickButtonValueByJoystickIndex(base.joystickID, inputIndex);
			bool flag = false;
			if (joystickButtonValueByJoystickIndex != lastState)
			{
				lastChangeTime = Time.realtimeSinceStartup;
				lastState = joystickButtonValueByJoystickIndex;
			}
			float num = Time.realtimeSinceStartup - lastChangeTime;
			if (joystickButtonValueByJoystickIndex)
			{
				canRelease = num < 0.4f;
			}
			else
			{
				flag = canRelease && num < 0.1f;
			}
			if (joystickButtonValueByJoystickIndex)
			{
				vrControllers.SetButtonValueById(inputIDs[0], joystickButtonValueByJoystickIndex);
			}
			if (flag)
			{
				vrControllers.SetButtonValueById(inputIDs[1], flag);
			}
		}
	}
	internal class LegacyReleaseAndHoldableButtonInput : LegacyInput
	{
		private float lastChangeTime;

		private bool lastState;

		private bool canRelease;

		internal LegacyReleaseAndHoldableButtonInput(bool leftController, int inputIndex, params int[] inputIDs)
			: base(leftController, inputIndex, inputIDs)
		{
		}

		internal override void UpdateValues(CustomController vrControllers)
		{
			bool joystickButtonValueByJoystickIndex = UnityInputHelper.GetJoystickButtonValueByJoystickIndex(base.joystickID, inputIndex);
			bool flag = false;
			bool flag2 = false;
			if (joystickButtonValueByJoystickIndex != lastState)
			{
				lastChangeTime = Time.realtimeSinceStartup;
				lastState = joystickButtonValueByJoystickIndex;
			}
			float num = Time.realtimeSinceStartup - lastChangeTime;
			if (joystickButtonValueByJoystickIndex)
			{
				if (num < 0.4f)
				{
					canRelease = true;
				}
				else
				{
					flag2 = true;
					canRelease = false;
				}
			}
			else
			{
				flag = canRelease && num < 0.1f;
			}
			if (flag)
			{
				vrControllers.SetButtonValueById(inputIDs[0], flag);
			}
			if (flag2)
			{
				vrControllers.SetButtonValueById(inputIDs[1], flag2);
			}
		}
	}
}
namespace VRMod.Haptics
{
	internal class BHapticsController : GenericHapticsController
	{
		private HapticPlayer hapticPlayer;

		private bool initialized;

		private bool shouldPlayHearthBeat;

		private Coroutine hearthBeatCoroutine;

		internal BHapticsController()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			try
			{
				hapticPlayer = new HapticPlayer("RiskOfRain2VRMod", "RiskOfRain2VRMod", true);
				RegisterAllTactFiles();
			}
			catch (Exception ex)
			{
				Debug.LogException(ex);
				VRMod.StaticLogger.LogError((object)"Could not initialize Bhaptics suit!");
			}
		}

		private void RegisterAllTactFiles()
		{
			FileInfo[] files = new DirectoryInfo(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\bHaptics").GetFiles("*.tact", SearchOption.AllDirectories);
			for (int i = 0; i < files.Length; i++)
			{
				string name = files[i].Name;
				string fullName = files[i].FullName;
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(name);
				if (!(name == ".") && !(name == ".."))
				{
					string text = File.ReadAllText(fullName);
					try
					{
						hapticPlayer.RegisterTactFileStr(fileNameWithoutExtension, text);
					}
					catch (Exception ex)
					{
						VRMod.StaticLogger.LogError((object)("Failed to register tact pattern: " + fileNameWithoutExtension));
						Debug.LogException(ex);
					}
				}
			}
			initialized = true;
		}

		private void PlayDamagePattern(string pattern, float intensity, float duration)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			hapticPlayer.SubmitRegistered(pattern, new ScaleOption(intensity, duration / 50f));
		}

		internal override bool Initialized()
		{
			return initialized;
		}

		internal override void Update(bool isHealthLow)
		{
			if (hearthBeatCoroutine == null && isHealthLow)
			{
				hearthBeatCoroutine = ((MonoBehaviour)RoR2Application.instance).StartCoroutine(HearthBeatCoroutine());
			}
			shouldPlayHearthBeat = isHealthLow;
		}

		internal override void OnHealthSpentOnInteractable(float healthPercent)
		{
			PlayDamagePattern("HearthDamage", 1f, healthPercent * 1000f);
		}

		internal override void OnFallDamageTaken(float healthPercent)
		{
			PlayDamagePattern(hapticPlayer.IsActive((PositionType)8) ? "FallDamage_Feet" : "FallDamage_Vest", 1f, healthPercent * 800f);
		}

		internal override void OnDirectionalDamageTaken(Vector3 localDirection, float healthPercent)
		{
			//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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			Vector3 val = -localDirection;
			Vector3 val2 = val;
			val2.y = 0f;
			((Vector3)(ref val2)).Normalize();
			float num = ((val2 == Vector3.zero) ? 0f : ((0f - Vector3.SignedAngle(Vector3.forward, val2, Vector3.up) + 360f) % 360f));
			ScaleOption val3 = new ScaleOption(0.3f + healthPercent * 0.7f, 2f + healthPercent * 14f);
			RotationOption val4 = new RotationOption(num, val.y / 2f);
			hapticPlayer.SubmitRegisteredVestRotation("Damage", "Damage", val4, val3);
		}

		internal override void OnEnvironmentDamageTaken(float healthPercent)
		{
			PlayDamagePattern("HearthDamage", 0.5f, healthPercent * 1000f);
		}

		internal override void OnDeath()
		{
			hapticPlayer.SubmitRegistered("Death_Vest");
			if (hapticPlayer.IsActive((PositionType)10))
			{
				hapticPlayer.SubmitRegistered("Death_Arms");
			}
			if (hapticPlayer.IsActive((PositionType)6))
			{
				hapticPlayer.SubmitRegistered("Death_Hands");
			}
			if (hapticPlayer.IsActive((PositionType)8))
			{
				hapticPlayer.SubmitRegistered("Death_Feet");
			}
		}

		private IEnumerator HearthBeatCoroutine()
		{
			do
			{
				hapticPlayer.SubmitRegistered("Heartbeat");
				yield return (object)new WaitForSeconds(0.75f);
			}
			while (shouldPlayHearthBeat);
			hearthBeatCoroutine = null;
		}
	}
	internal abstract class GenericHapticsController
	{
		internal abstract bool Initialized();

		internal abstract void Update(bool isHealthLow);

		internal abstract void OnFallDamageTaken(float healthPercent);

		internal abstract void OnHealthSpentOnInteractable(float healthPercent);

		internal abstract void OnDirectionalDamageTaken(Vector3 localDirection, float healthPercent);

		internal abstract void OnEnvironmentDamageTaken(float healthPercent);

		internal abstract void OnDeath();
	}
	internal class HapticsManager
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Action<DamageDealtMessage> <0>__OnClientDamage;

			public static hook_OnInteractionBegin <1>__CheckForHealthCost;

			public static Action <2>__Update;

			public static hook_OnBodyDeath <3>__OnDeath;
		}

		private static GenericHapticsController hapticsController;

		private static Vector3 approximateChestRotation;

		internal static void Init()
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			if (ModConfig.HapticsSuit.Value == "Shockwave")
			{
				hapticsController = CreateShockwave();
			}
			else
			{
				if (!(ModConfig.HapticsSuit.Value == "Bhaptics"))
				{
					return;
				}
				hapticsController = CreateBHaptics();
			}
			if (hapticsController.Initialized())
			{
				GlobalEventManager.onClientDamageNotified += OnClientDamage;
				object obj = <>O.<1>__CheckForHealthCost;
				if (obj == null)
				{
					hook_OnInteractionBegin val = CheckForHealthCost;
					<>O.<1>__CheckForHealthCost = val;
					obj = (object)val;
				}
				PurchaseInteraction.OnInteractionBegin += (hook_OnInteractionBegin)obj;
				RoR2Application.onUpdate += Update;
				object obj2 = <>O.<3>__OnDeath;
				if (obj2 == null)
				{
					hook_OnBodyDeath val2 = OnDeath;
					<>O.<3>__OnDeath = val2;
					obj2 = (object)val2;
				}
				CharacterMaster.OnBodyDeath += (hook_OnBodyDeath)obj2;
			}
		}

		private static void OnDeath(orig_OnBodyDeath orig, CharacterMaster self, CharacterBody body)
		{
			if ((Object)(object)self == (Object)(object)Utils.localMaster)
			{
				hapticsController.OnDeath();
			}
			orig.Invoke(self, body);
		}

		private static void Update()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			hapticsController.Update(Object.op_Implicit((Object)(object)Utils.localBody) && Utils.localBody.healthComponent.isHealthLow && Utils.localBody.healthComponent.alive);
			if (Object.op_Implicit((Object)(object)Utils.localCameraRig))
			{
				Transform transform = ((Component)Utils.localCameraRig.sceneCam).transform;
				Vector3 val = Vector3.Cross(transform.right, Vector3.up);
				HandController handBySide = MotionControls.GetHandBySide(left: true);
				HandController handBySide2 = MotionControls.GetHandBySide(left: false);
				Quaternion val4;
				if ((Object)(object)handBySide != (Object)null && (Object)(object)handBySide2 != (Object)null)
				{
					Vector3 val2 = ((Component)handBySide).transform.position - transform.position;
					val2.y = 0f;
					Vector3 val3 = ((Component)handBySide2).transform.position - transform.position;
					val3.y = 0f;
					float num = Vector3.SignedAngle(val, val2, Vector3.up);
					float num2 = Vector3.SignedAngle(val, val3, Vector3.up);
					val4 = Quaternion.LookRotation(Quaternion.Euler(new Vector3(0f, (num + num2) / 3f, 0f)) * val);
					approximateChestRotation = ((Quaternion)(ref val4)).eulerAngles;
				}
				else
				{
					val4 = Quaternion.LookRotation(val);
					approximateChestRotation = ((Quaternion)(ref val4)).eulerAngles;
				}
			}
		}

		private static void CheckForHealthCost(orig_OnInteractionBegin orig, PurchaseInteraction self, Interactor activator)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			if (self.CanBeAffordedByInteractor(activator))
			{
				if ((int)self.costType == 2)
				{
					hapticsController.OnHealthSpentOnInteractable((float)self.cost / 100f);
				}
				orig.Invoke(self, activator);
			}
		}

		private static GenericHapticsController CreateShockwave()
		{
			return new ShockwaveController();
		}

		private static GenericHapticsController CreateBHaptics()
		{
			return new BHapticsController();
		}

		private static void OnClientDamage(DamageDealtMessage dmgMessage)
		{
			//IL_0029: 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_0043: Invalid comparison between Unknown and I4
			//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_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)dmgMessage.victim))
			{
				return;
			}
			HealthComponent component = dmgMessage.victim.GetComponent<HealthComponent>();
			if (component.body.IsLocalBody())
			{
				if ((int)DamageTypeCombo.op_Implicit(dmgMessage.damageType & DamageTypeCombo.op_Implicit((DamageType)2097152)) > 0)
				{
					hapticsController.OnFallDamageTaken(dmgMessage.damage / component.fullHealth);
				}
				else if ((Object)(object)dmgMessage.attacker == (Object)null)
				{
					hapticsController.OnEnvironmentDamageTaken(dmgMessage.damage / component.fullHealth);
				}
				else if ((Object)(object)dmgMessage.attacker.GetComponent<PurchaseInteraction>() == (Object)null)
				{
					Vector3 val = dmgMessage.victim.transform.TransformPoint(dmgMessage.victim.GetComponent<CapsuleCollider>().center) - dmgMessage.position;
					Quaternion val2 = Quaternion.LookRotation(((Vector3)(ref val)).normalized);
					Vector3 localDirection = Quaternion.Euler(((Quaternion)(ref val2)).eulerAngles - approximateChestRotation) * Vector3.forward;
					hapticsController.OnDirectionalDamageTaken(localDirection, dmgMessage.damage / component.fullHealth);
				}
			}
		}
	}
	internal class ShockwaveController : GenericHapticsController
	{
		private bool shouldPlayHearthBeat;

		private Coroutine hearthBeatCoroutine;

		private static KeyValuePair<Vector3, HapticGroup>[] directionToHapticGroup;

		internal ShockwaveController()
		{
			ShockwaveManager.Instance.enableBodyTracking = false;
			ShockwaveManager.Instance.InitializeSuit();
			if (!ShockwaveManager.Instance.Ready)
			{
				VRMod.StaticLogger.LogError((object)"Could not initialize Shockwave suit!");
			}
		}

		internal override bool Initialized()
		{
			return ShockwaveManager.Instance.Ready;
		}

		internal override void Update(bool isHealthLow)
		{
			if (hearthBeatCoroutine == null && isHealthLow)
			{
				hearthBeatCoroutine = ((MonoBehaviour)RoR2Application.instance).StartCoroutine(HearthBeatCoroutine());
			}
			shouldPlayHearthBeat = isHealthLow;
		}

		internal override void OnHealthSpentOnInteractable(float healthPercent)
		{
			ShockwaveManager.Instance.sendHapticsPulse(24, 2f, healthPercent * 1000f);
		}

		internal override void OnFallDamageTaken(float healthPercent)
		{
			ShockwaveManager.Instance.SendHapticGroup((HapticGroup)14, 2f, (int)(healthPercent * 800f));
			ShockwaveManager.Instance.SendHapticGroup((HapticGroup)17, 2f, (int)(healthPercent * 800f));
		}

		internal override void OnDirectionalDamageTaken(Vector3 localDirection, float healthPercent)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			KeyValuePair<Vector3, HapticGroup> keyValuePair = directionToHapticGroup[0];
			for (int i = 1; i < directionToHapticGroup.Length; i++)
			{
				if (Vector3.Angle(localDirection, directionToHapticGroup[i].Key) < Vector3.Angle(localDirection, keyValuePair.Key))
				{
					keyValuePair = directionToHapticGroup[i];
				}
			}
			ShockwaveManager.Instance.SendHapticGroup(keyValuePair.Value, 0.5f + healthPercent * 2f, 100 + (int)(healthPercent * 700f));
		}

		internal override void OnEnvironmentDamageTaken(float healthPercent)
		{
			ShockwaveManager.Instance.sendHapticsPulse(24, 1f, healthPercent * 1000f);
		}

		internal override void OnDeath()
		{
			((MonoBehaviour)RoR2Application.instance).StartCoroutine(DeathCoroutine());
		}

		private IEnumerator HearthBeatCoroutine()
		{
			do
			{
				ShockwaveManager.Instance.sendHapticsPulse(24, 0.5f, 10f);
				yield return (object)new WaitForSeconds(0.25f);
				ShockwaveManager.Instance.sendHapticsPulse(24, 0.3f, 10f);
				yield return (object)new WaitForSeconds(0.5f);
			}
			while (shouldPlayHearthBeat);
			hearthBeatCoroutine = null;
		}

		private IEnumerator DeathCoroutine()
		{
			ShockwaveManager.Instance.SendHapticGroup((HapticGroup)5, 2f, 200);
			yield return (object)new WaitForSeconds(0.2f);
			ShockwaveManager.Instance.SendHapticGroup((HapticGroup)4, 2f, 200);
			ShockwaveManager.Instance.SendHapticGroup((HapticGroup)7, 2f, 200);
			ShockwaveManager.Instance.SendHapticGroup((HapticGroup)10, 2f, 200);
			yield return (object)new WaitForSeconds(0.2f);
			ShockwaveManager.Instance.SendHapticGroup((HapticGroup)3, 2f, 200);
			ShockwaveManager.Instance.SendHapticGroup((HapticGroup)8, 2f, 200);
			ShockwaveManager.Instance.SendHapticGroup((HapticGroup)11, 2f, 200);
			yield return (object)new WaitForSeconds(0.2f);
			ShockwaveManager.Instance.SendHapticGroup((HapticGroup)2, 2f, 200);
			yield return (object)new WaitForSeconds(0.2f);
			ShockwaveManager.Instance.SendHapticGroup((HapticGroup)1, 2f, 200);
			yield return (object)new WaitForSeconds(0.2f);
			ShockwaveManager.Instance.SendHapticGroup((HapticGroup)13, 2f, 200);
			ShockwaveManager.Instance.SendHapticGroup((HapticGroup)16, 2f, 200);
			yield return (object)new WaitForSeconds(0.2f);
			ShockwaveManager.Instance.SendHapticGroup((HapticGroup)14, 2f, 200);
			ShockwaveManager.Instance.SendHapticGroup((HapticGroup)17, 2f, 200);
		}

		static ShockwaveController()
		{
			//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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: 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_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: 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_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			KeyValuePair<Vector3, HapticGroup>[] array = new KeyValuePair<Vector3, HapticGroup>[20];
			Vector3 val = new Vector3(-0.2f, 1f, -0.2f);
			array[0] = new KeyValuePair<Vector3, HapticGroup>(((Vector3)(ref val)).normalized, (HapticGroup)21);
			val = new Vector3(-0.2f, 1f, 0.2f);
			array[1] = new KeyValuePair<Vector3, HapticGroup>(((Vector3)(ref val)).normalized, (HapticGroup)49);
			val = new Vector3(0.2f, 1f, -0.2f);
			array[2] = new KeyValuePair<Vector3, HapticGroup>(((Vector3)(ref val)).normalized, (HapticGroup)20);
			val = new Vector3(0.2f, 1f, 0.2f);
			array[3] = new KeyValuePair<Vector3, HapticGroup>(((Vector3)(ref val)).normalized, (HapticGroup)48);
			val = new Vector3(-0.6f, 0.5f, -0.6f);
			array[4] = new KeyValuePair<Vector3, HapticGroup>(((Vector3)(ref val)).normalized, (HapticGroup)24);
			val = new Vector3(-0.6f, 0.5f, 0.6f);
			array[5] = new KeyValuePair<Vector3, HapticGroup>(((Vector3)(ref val)).normalized, (HapticGroup)52);
			val = new Vector3(0.6f, 0.5f, -0.6f);
			array[6] = new KeyValuePair<Vector3, HapticGroup>(((Vector3)(ref val)).normalized, (HapticGroup)23);
			val = new Vector3(0.6f, 0.5f, 0.6f);
			array[7] = new KeyValuePair<Vector3, HapticGroup>(((Vector3)(ref val)).normalized, (HapticGroup)51);
			val = new Vector3(-1f, 0f, -1f);
			array[8] = new KeyValuePair<Vector3, HapticGroup>(((Vector3)(ref val)).normalized, (HapticGroup)27);
			val = new Vector3(-1f, 0f, 1f);
			array[9] = new KeyValuePair<Vector3, HapticGroup>(((Vector3)(ref val)).normalized, (HapticGroup)55);
			val = new Vector3(1f, 0f, -1f);
			array[10] = new KeyValuePair<Vector3, HapticGroup>(((Vector3)(ref val)).normalized, (HapticGroup)26);
			val = new Vector3(1f, 0f, 1f);
			array[11] = new KeyValuePair<Vector3, HapticGroup>(((Vector3)(ref val)).normalized, (HapticGroup)54);
			val = new Vector3(-0.6f, -0.5f, -0.6f);
			array[12] = new KeyValuePair<Vector3, HapticGroup>(((Vector3)(ref val)).normalized, (HapticGroup)30);
			val = new Vector3(-0.6f, -0.5f, 0.6f);
			array[13] = new KeyValuePair<Vector3, HapticGroup>(((Vector3)(ref val)).normalized, (HapticGroup)58);
			val = new Vector3(0.6f, -0.5f, -0.6f);
			array[14] = new KeyValuePair<Vector3, HapticGroup>(((Vector3)(ref val)).normalized, (HapticGroup)29);
			val = new Vector3(0.6f, -0.5f, 0.6f);
			array[15] = new KeyValuePair<Vector3, HapticGroup>(((Vector3)(ref val)).normalized, (HapticGroup)57);
			val = new Vector3(-0.2f, -1f, -0.2f);
			array[16] = new KeyValuePair<Vector3, HapticGroup>(((Vector3)(ref val)).normalized, (HapticGroup)33);
			val = new Vector3(-0.2f, -1f, 0.2f);
			array[17] = new KeyValuePair<Vector3, HapticGroup>(((Vector3)(ref val)).normalized, (HapticGroup)61);
			val = new Vector3(0.2f, -1f, -0.2f);
			array[18] = new KeyValuePair<Vector3, HapticGroup>(((Vector3)(ref val)).normalized, (HapticGroup)32);
			val = new Vector3(0.2f, -1f, 0.2f);
			array[19] = new KeyValuePair<Vector3, HapticGroup>(((Vector3)(ref val)).normalized, (HapticGroup)60);
			directionToHapticGroup = array;
		}
	}
}