using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Diagnostics.SymbolStore;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Timers;
using System.Xml;
using System.Xml.Serialization;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using CinematicUnityExplorer.Cinematic;
using HarmonyLib;
using Il2CppInterop.Common;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Attributes;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections;
using Il2CppSystem.Collections.Generic;
using Microsoft.CodeAnalysis;
using Mono.CSharp;
using Mono.CSharp.IL2CPP;
using Mono.CSharp.Linq;
using Mono.CSharp.Nullable;
using Mono.CSharp.yyParser;
using Mono.CSharp.yydebug;
using Mono.CompilerServices.SymbolWriter;
using MonoMod.RuntimeDetour;
using Tomlet;
using Tomlet.Attributes;
using Tomlet.Exceptions;
using Tomlet.Models;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityExplorer;
using UnityExplorer.CSConsole;
using UnityExplorer.CSConsole.Lexers;
using UnityExplorer.CacheObject;
using UnityExplorer.CacheObject.IValues;
using UnityExplorer.CacheObject.Views;
using UnityExplorer.CatmullRom;
using UnityExplorer.Config;
using UnityExplorer.Hooks;
using UnityExplorer.Inspectors;
using UnityExplorer.Inspectors.MouseInspectors;
using UnityExplorer.Loader.BIE;
using UnityExplorer.ObjectExplorer;
using UnityExplorer.Runtime;
using UnityExplorer.Serializers;
using UnityExplorer.UI;
using UnityExplorer.UI.Panels;
using UnityExplorer.UI.Widgets;
using UnityExplorer.UI.Widgets.AutoComplete;
using UniverseLib;
using UniverseLib.Config;
using UniverseLib.Input;
using UniverseLib.Runtime;
using UniverseLib.UI;
using UniverseLib.UI.Models;
using UniverseLib.UI.ObjectPool;
using UniverseLib.UI.Panels;
using UniverseLib.UI.Widgets;
using UniverseLib.UI.Widgets.ButtonList;
using UniverseLib.UI.Widgets.ScrollView;
using UniverseLib.Utility;

[assembly: AssemblyTitle("CinematicUnityExplorer")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyCompany("originalnicodr, Sinai, yukieiji")]
[assembly: Guid("b21dbde3-5d6f-4726-93ab-cc3cc68bae7d")]
[assembly: AssemblyFileVersion("1.4.0")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: ComVisible(false)]
[assembly: AssemblyProduct("CinematicUnityExplorer")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.4.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<300de733-bc39-4fd0-9379-95bf3e51a662>Embedded]
	internal sealed class <300de733-bc39-4fd0-9379-95bf3e51a662>EmbeddedAttribute : System.Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[<300de733-bc39-4fd0-9379-95bf3e51a662>Embedded]
	[CompilerGenerated]
	internal sealed class <267d1362-9a20-4ec0-a85c-2e4ffe48c491>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <267d1362-9a20-4ec0-a85c-2e4ffe48c491>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <267d1362-9a20-4ec0-a85c-2e4ffe48c491>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[<300de733-bc39-4fd0-9379-95bf3e51a662>Embedded]
	internal sealed class <320efdd9-03d8-4ad3-a3ae-8138e3594e43>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <320efdd9-03d8-4ad3-a3ae-8138e3594e43>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace CinematicUnityExplorer.Cinematic
{
	internal static class NativeMethods
	{
		[DllImport("kernel32.dll")]
		public static extern IntPtr LoadLibrary(string dll);

		[DllImport("kernel32.dll")]
		public static extern IntPtr GetProcAddress(IntPtr hModule, string procName);
	}
	public class UnityIGCSConnector
	{
		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		private delegate void MoveCameraCallback(float step_left, float step_up, float fov, int from_start);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		private delegate void SessionCallback();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		private delegate IntPtr U_IGCS_Initialize(MoveCameraCallback callback, SessionCallback start_cb, SessionCallback end_cb);

		private Mono.CSharp.Tuple<Vector3, Quaternion> position = null;

		private Mono.CSharp.Tuple<Vector3, Quaternion> endSessionPosition = null;

		private readonly bool isValid = false;

		private bool _isActive = false;

		private readonly List<System.Delegate> delegates = new List<System.Delegate>();

		private readonly Queue<Mono.CSharp.Tuple<float, float>> commands = new Queue<Mono.CSharp.Tuple<float, float>>();

		private IntPtr CameraStatus = IntPtr.Zero;

		public bool IsActive => isValid && _isActive;

		public void UpdateFreecamStatus(bool enabled)
		{
			if (!(CameraStatus == IntPtr.Zero))
			{
				Marshal.WriteByte(CameraStatus, (byte)(enabled ? 1 : 0));
			}
		}

		public void ExecuteCameraCommand(Camera cam)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: 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)
			Transform transform = ((Component)cam).transform;
			ShouldMoveToOriginalPosition(transform);
			if (!_isActive || position == null)
			{
				position = new Mono.CSharp.Tuple<Vector3, Quaternion>(transform.position, transform.rotation);
			}
			if (!_isActive || position == null)
			{
				return;
			}
			Mono.CSharp.Tuple<float, float> tuple = null;
			lock (commands)
			{
				if (commands.Count <= 0)
				{
					return;
				}
				tuple = commands.Dequeue();
			}
			transform.position = position.Item1;
			transform.rotation = position.Item2;
			transform.Translate(tuple.Item1, tuple.Item2, 0f);
		}

		private void MoveCamera(float stepLeft, float stepUp, float fov, int fromStart)
		{
			lock (commands)
			{
				commands.Enqueue(new Mono.CSharp.Tuple<float, float>(stepLeft, stepUp));
			}
		}

		private void StartSession()
		{
			_isActive = true;
		}

		public void ShouldMoveToOriginalPosition(Transform transform)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (isValid && endSessionPosition != null)
			{
				transform.position = endSessionPosition.Item1;
				transform.rotation = endSessionPosition.Item2;
				endSessionPosition = null;
			}
		}

		private void EndSession()
		{
			endSessionPosition = position;
			position = null;
			_isActive = false;
			lock (commands)
			{
				commands.Clear();
			}
		}

		public UnityIGCSConnector()
		{
			string text = ((IntPtr.Size == 8) ? "UnityIGCSConnector.dll" : "UnityIGCSConnector.32.dll");
			IntPtr intPtr = NativeMethods.LoadLibrary(text);
			if (intPtr == IntPtr.Zero)
			{
				ExplorerCore.LogWarning(text + " was not found so IGCSDof will not be available");
				return;
			}
			IntPtr procAddress = NativeMethods.GetProcAddress(intPtr, "U_IGCS_Initialize");
			if (procAddress == IntPtr.Zero)
			{
				throw new EntryPointNotFoundException("Failed to find 'U_IGCS_Initialize' which means you can have a corrupt UnityIGCSConnector.dll.");
			}
			U_IGCS_Initialize u_IGCS_Initialize = (U_IGCS_Initialize)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(U_IGCS_Initialize));
			delegates.Add(new MoveCameraCallback(MoveCamera));
			delegates.Add(new SessionCallback(StartSession));
			delegates.Add(new SessionCallback(EndSession));
			CameraStatus = u_IGCS_Initialize((MoveCameraCallback)delegates[0], (SessionCallback)delegates[1], (SessionCallback)delegates[2]);
			if (CameraStatus == IntPtr.Zero)
			{
				throw new Exception("IGCSDof returned an invalid pointer which means something went wrong");
			}
			isValid = true;
		}
	}
}
namespace UniverseLib.Input
{
	public static class IGamepadInputInterceptor
	{
		private static bool _isEnabled = false;

		private static int _targetGamepadIndex = 0;

		private static Type _gamepadType;

		private static Type _buttonControlType;

		private static Type _axisControlType;

		private static Type _vector2ControlType;

		private static Type _inputControlType;

		private static PropertyInfo _basePathProp;

		private static PropertyInfo _buttonIsPressedProp;

		private static PropertyInfo _buttonWasPressedProp;

		private static PropertyInfo _buttonWasReleasedProp;

		private static MethodInfo _axisReadValueMethod;

		private static MethodInfo _vector2ReadValueMethod;

		private static PropertyInfo _deviceProp;

		private static PropertyInfo _vector2XProp;

		private static PropertyInfo _vector2YProp;

		private static PropertyInfo _gamepadAllProp;

		private static PropertyInfo _gamepadCurrentProp;

		private static PropertyInfo _gamepadLeftStickProp;

		private static PropertyInfo _gamepadRightStickProp;

		private static readonly Dictionary<string, string> _vendorPrefixMap = new Dictionary<string, string>
		{
			{ "/xinputcontrollerwindows", "/gamepad" },
			{ "/xinputcontroller", "/gamepad" },
			{ "/dualshockgamepad", "/gamepad" },
			{ "/dualsensegamepad", "/gamepad" },
			{ "/dualshock4gamepadhid", "/gamepad" },
			{ "/dualshock3gamepadhid", "/gamepad" },
			{ "/androidgamepad", "/gamepad" },
			{ "/switchprocontrollerhid", "/gamepad" }
		};

		private static readonly Dictionary<string, object> _axisControls = new Dictionary<string, object>();

		private static readonly Dictionary<string, object> _vector2Controls = new Dictionary<string, object>();

		private static readonly Dictionary<string, float> _axisValues = new Dictionary<string, float>();

		private static readonly Dictionary<string, Vector2> _vector2Values = new Dictionary<string, Vector2>();

		public static void Init()
		{
			try
			{
				LoadReflectedTypes();
				if (!(_gamepadType == null) && !(_axisControlType == null))
				{
					PatchAnalogControls();
					DiscoverGamepadControls();
					_isEnabled = true;
				}
			}
			catch (Exception ex)
			{
				ExplorerCore.LogWarning("[IGamepadInputInterceptor] Init failed: " + ex.Message + "\n" + ex.StackTrace);
			}
		}

		public static void Enable()
		{
			_isEnabled = true;
		}

		public static void Disable()
		{
			_isEnabled = false;
		}

		public static void SetTargetGamepad(int index)
		{
			_targetGamepadIndex = index;
			ClearControlCaches();
			DiscoverGamepadControls();
		}

		private static void LoadReflectedTypes()
		{
			_gamepadType = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Gamepad, Unity.InputSystem");
			_buttonControlType = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Controls.ButtonControl, Unity.InputSystem");
			_axisControlType = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Controls.AxisControl, Unity.InputSystem");
			_vector2ControlType = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Controls.Vector2Control, Unity.InputSystem");
			_inputControlType = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.InputControl, Unity.InputSystem");
			_basePathProp = _inputControlType?.GetProperty("path", BindingFlags.Instance | BindingFlags.Public);
			_buttonIsPressedProp = _buttonControlType?.GetProperty("isPressed", BindingFlags.Instance | BindingFlags.Public);
			_buttonWasPressedProp = _buttonControlType?.GetProperty("wasPressedThisFrame", BindingFlags.Instance | BindingFlags.Public);
			_buttonWasReleasedProp = _buttonControlType?.GetProperty("wasReleasedThisFrame", BindingFlags.Instance | BindingFlags.Public);
			_axisReadValueMethod = _axisControlType?.GetMethod("ReadValue", Type.EmptyTypes);
			_vector2ReadValueMethod = _vector2ControlType?.GetMethod("ReadValue", Type.EmptyTypes);
			_deviceProp = _inputControlType?.GetProperty("device", BindingFlags.Instance | BindingFlags.Public);
			_vector2XProp = _vector2ControlType?.GetProperty("x", BindingFlags.Instance | BindingFlags.Public);
			_vector2YProp = _vector2ControlType?.GetProperty("y", BindingFlags.Instance | BindingFlags.Public);
			_gamepadAllProp = _gamepadType?.GetProperty("all", BindingFlags.Static | BindingFlags.Public);
			_gamepadCurrentProp = _gamepadType?.GetProperty("current", BindingFlags.Static | BindingFlags.Public);
			_gamepadLeftStickProp = _gamepadType?.GetProperty("leftStick", BindingFlags.Instance | BindingFlags.Public);
			_gamepadRightStickProp = _gamepadType?.GetProperty("rightStick", BindingFlags.Instance | BindingFlags.Public);
		}

		private static void LogLoadedType(string name, Type type)
		{
			if (type != null)
			{
				ExplorerCore.LogWarning("[IGamepadInputInterceptor] Loaded type: " + name);
			}
			else
			{
				ExplorerCore.LogWarning("[IGamepadInputInterceptor] Failed to load type: " + name);
			}
		}

		private static void PatchAnalogControls()
		{
			try
			{
				if (_vector2ControlType != null)
				{
					MethodInfo method = _vector2ControlType.GetMethod("ReadValue", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null);
					if (method == null)
					{
						Type baseType = _vector2ControlType.BaseType;
						if (baseType != null && baseType.IsGenericType)
						{
							method = baseType.GetMethod("ReadValue", BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null);
						}
					}
					if (method != null)
					{
						PatchMethod(method, null, "Postfix_Vector2ReadValue");
					}
				}
				if (!(_axisControlType != null))
				{
					return;
				}
				MethodInfo method2 = _axisControlType.GetMethod("ReadValue", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null);
				if (method2 == null)
				{
					Type baseType2 = _axisControlType.BaseType;
					if (baseType2 != null && baseType2.IsGenericType)
					{
						method2 = baseType2.GetMethod("ReadValue", BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null);
					}
				}
				if (method2 != null)
				{
					PatchMethod(method2, null, "Postfix_AxisReadValue");
				}
			}
			catch (Exception ex)
			{
				ExplorerCore.LogWarning("[IGamepadInputInterceptor] Error during patching: " + ex.Message);
			}
		}

		private static void PatchMethod(MethodInfo method, string prefixName, string postfixName)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!(method == null) && !(Il2CppInteropUtils.GetIl2CppMethodInfoPointerFieldForGeneratedMethod((MethodBase)method) == null))
				{
					MethodInfo methodInfo = ((prefixName != null) ? AccessTools.Method(typeof(IGamepadInputInterceptor), prefixName, (Type[])null, (Type[])null) : null);
					MethodInfo methodInfo2 = ((postfixName != null) ? AccessTools.Method(typeof(IGamepadInputInterceptor), postfixName, (Type[])null, (Type[])null) : null);
					ExplorerCore.Harmony.Patch((MethodBase)method, (!(methodInfo != null)) ? ((HarmonyMethod)null) : new HarmonyMethod(methodInfo), (!(methodInfo2 != null)) ? ((HarmonyMethod)null) : new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
			catch (Exception ex)
			{
				ExplorerCore.LogWarning("[IGamepadInputInterceptor] Failed to patch method: " + ex.Message);
			}
		}

		private static void DiscoverGamepadControls()
		{
			try
			{
				object gamepadInstance = GetGamepadInstance(_targetGamepadIndex);
				if (gamepadInstance == null)
				{
					return;
				}
				string[] array = new string[12]
				{
					"buttonSouth", "buttonNorth", "buttonWest", "buttonEast", "leftStickButton", "rightStickButton", "leftShoulder", "rightShoulder", "startButton", "selectButton",
					"leftTrigger", "rightTrigger"
				};
				string[] array2 = new string[2] { "leftStick", "rightStick" };
				string[] array3 = array;
				foreach (string text in array3)
				{
					try
					{
						PropertyInfo property = _gamepadType.GetProperty(text, BindingFlags.Instance | BindingFlags.Public);
						if (!(property != null))
						{
							continue;
						}
						object value = property.GetValue(gamepadInstance, BindingFlags.Default, null, null, null);
						if (value != null)
						{
							string text2 = ExtractAndNormalizePath(value);
							if (!string.IsNullOrEmpty(text2))
							{
								INewInputSystem.gamepadButtonControls[text2] = value;
							}
						}
					}
					catch (Exception ex)
					{
						ExplorerCore.LogWarning("[IGamepadInputInterceptor] Failed to access button " + text + ": " + ex.Message);
					}
				}
				try
				{
					PropertyInfo property2 = _gamepadType.GetProperty("dpad", BindingFlags.Instance | BindingFlags.Public);
					if (property2 != null)
					{
						object value2 = property2.GetValue(gamepadInstance, BindingFlags.Default, null, null, null);
						if (value2 != null)
						{
							string[] array4 = new string[4] { "up", "down", "left", "right" };
							string[] array5 = array4;
							foreach (string text3 in array5)
							{
								try
								{
									PropertyInfo property3 = value2.GetType().GetProperty(text3, BindingFlags.Instance | BindingFlags.Public);
									if (!(property3 != null))
									{
										continue;
									}
									object value3 = property3.GetValue(value2, BindingFlags.Default, null, null, null);
									if (value3 != null)
									{
										string text4 = ExtractAndNormalizePath(value3);
										if (!string.IsNullOrEmpty(text4))
										{
											INewInputSystem.gamepadButtonControls[text4] = value3;
										}
									}
								}
								catch (Exception ex2)
								{
									ExplorerCore.LogWarning("[IGamepadInputInterceptor] Failed to access dpad." + text3 + ": " + ex2.Message);
								}
							}
						}
					}
				}
				catch (Exception ex3)
				{
					ExplorerCore.LogWarning("[IGamepadInputInterceptor] Failed to access dpad: " + ex3.Message);
				}
				string[] array6 = array2;
				foreach (string text5 in array6)
				{
					try
					{
						PropertyInfo property4 = _gamepadType.GetProperty(text5, BindingFlags.Instance | BindingFlags.Public);
						if (!(property4 != null))
						{
							continue;
						}
						object value4 = property4.GetValue(gamepadInstance, BindingFlags.Default, null, null, null);
						if (value4 == null)
						{
							continue;
						}
						string text6 = ExtractAndNormalizePath(value4);
						if (!string.IsNullOrEmpty(text6))
						{
							_vector2Controls[text6] = value4;
						}
						string[] array7 = new string[2] { "x", "y" };
						string[] array8 = array7;
						foreach (string text7 in array8)
						{
							try
							{
								PropertyInfo property5 = value4.GetType().GetProperty(text7, BindingFlags.Instance | BindingFlags.Public);
								if (!(property5 != null))
								{
									continue;
								}
								object value5 = property5.GetValue(value4, BindingFlags.Default, null, null, null);
								if (value5 != null)
								{
									string value6 = ExtractAndNormalizePath(value5);
									if (!string.IsNullOrEmpty(value6))
									{
										string text8 = text5.ToLowerInvariant();
										string key = "/gamepad/" + text8 + "/" + text7;
										_axisControls[key] = value5;
									}
								}
							}
							catch (Exception ex4)
							{
								ExplorerCore.LogWarning($"[IGamepadInputInterceptor] Failed to access {text5}.{text7}: {ex4.Message}");
							}
						}
					}
					catch (Exception ex5)
					{
						ExplorerCore.LogWarning("[IGamepadInputInterceptor] Failed to access vector2 " + text5 + ": " + ex5.Message);
					}
				}
				string[] array9 = new string[2] { "leftTrigger", "rightTrigger" };
				string[] array10 = array9;
				foreach (string text9 in array10)
				{
					try
					{
						PropertyInfo property6 = _gamepadType.GetProperty(text9, BindingFlags.Instance | BindingFlags.Public);
						if (!(property6 != null))
						{
							continue;
						}
						object value7 = property6.GetValue(gamepadInstance, BindingFlags.Default, null, null, null);
						if (value7 != null)
						{
							string text10 = ExtractAndNormalizePath(value7);
							if (!string.IsNullOrEmpty(text10))
							{
								_axisControls[text10] = value7;
							}
						}
					}
					catch (Exception ex6)
					{
						ExplorerCore.LogWarning("[IGamepadInputInterceptor] Failed to access " + text9 + ": " + ex6.Message);
					}
				}
				int num = INewInputSystem.gamepadButtonControls.Count + _axisControls.Count + _vector2Controls.Count;
			}
			catch (Exception ex7)
			{
				ExplorerCore.LogWarning("[IGamepadInputInterceptor] Error discovering controls: " + ex7.Message + "\n" + ex7.StackTrace);
			}
		}

		private static object GetGamepadInstance(int index)
		{
			try
			{
				if (_gamepadAllProp != null)
				{
					object value = _gamepadAllProp.GetValue(null, BindingFlags.Default, null, null, null);
					if (value != null)
					{
						Type type = value.GetType();
						PropertyInfo property = type.GetProperty("Count", BindingFlags.Instance | BindingFlags.Public);
						PropertyInfo property2 = type.GetProperty("Item", BindingFlags.Instance | BindingFlags.Public);
						if (property != null && property2 != null)
						{
							int num = (int)property.GetValue(value, BindingFlags.Default, null, null, null);
							if (index >= 0 && index < num)
							{
								return property2.GetValue(value, new object[1] { index });
							}
						}
					}
				}
				if (_gamepadCurrentProp != null)
				{
					return _gamepadCurrentProp.GetValue(null, BindingFlags.Default, null, null, null);
				}
				return null;
			}
			catch (Exception ex)
			{
				ExplorerCore.LogWarning("[IGamepadInputInterceptor] Error getting gamepad instance: " + ex.Message);
				return null;
			}
		}

		private static string ExtractAndNormalizePath(object control)
		{
			if (control == null)
			{
				return null;
			}
			string text = null;
			try
			{
				string text2 = control.ToString();
				if (!string.IsNullOrEmpty(text2))
				{
					int num = text2.IndexOf('/');
					if (num >= 0)
					{
						int num2 = text2.IndexOf('}', num);
						if (num2 >= 0)
						{
							text = text2.Substring(num, num2 - num);
						}
					}
				}
			}
			catch
			{
			}
			if (string.IsNullOrEmpty(text))
			{
				try
				{
					if (_basePathProp != null)
					{
						object value = _basePathProp.GetValue(control, BindingFlags.Default, null, null, null);
						text = value as string;
					}
				}
				catch
				{
				}
			}
			if (string.IsNullOrEmpty(text))
			{
				try
				{
					PropertyInfo property = control.GetType().GetProperty("name", BindingFlags.Instance | BindingFlags.Public);
					if (property != null)
					{
						string text3 = property.GetValue(control, BindingFlags.Default, null, null, null) as string;
						if (!string.IsNullOrEmpty(text3))
						{
							text = "/gamepad/" + text3;
						}
					}
				}
				catch
				{
				}
			}
			if (string.IsNullOrEmpty(text))
			{
				return null;
			}
			return NormalizeControlPath(text);
		}

		public static string NormalizeControlPath(string rawPath)
		{
			if (string.IsNullOrEmpty(rawPath))
			{
				return rawPath;
			}
			string text = rawPath.ToLowerInvariant().Trim();
			foreach (KeyValuePair<string, string> item in _vendorPrefixMap)
			{
				if (text.StartsWith(item.Key))
				{
					text = item.Value + text.Substring(item.Key.Length);
					break;
				}
			}
			int length = "/gamepad".Length;
			if (text.StartsWith("/gamepad") && text.Length > length && char.IsDigit(text[length]))
			{
				text = "/gamepad" + text.Substring(length + 1);
			}
			switch (text)
			{
			default:
				if (!(text == "/gamepad/right"))
				{
					break;
				}
				goto case "/gamepad/up";
			case "/gamepad/up":
			case "/gamepad/down":
			case "/gamepad/left":
			{
				string text2 = text.Substring("/gamepad/".Length);
				text = "/gamepad/dpad/" + text2;
				break;
			}
			}
			return text;
		}

		private static void ClearControlCaches()
		{
			INewInputSystem.gamepadButtonControls.Clear();
			_axisControls.Clear();
			_vector2Controls.Clear();
			_axisValues.Clear();
			_vector2Values.Clear();
		}

		public static bool IsButtonPressed(string buttonPath)
		{
			if (!_isEnabled)
			{
				return false;
			}
			string key = buttonPath.ToLower();
			if (INewInputSystem.gamepadButtonControls.TryGetValue(key, out var value) && _buttonIsPressedProp != null)
			{
				_buttonIsPressedProp.GetValue(value, BindingFlags.Default, null, null, null);
			}
			bool value2;
			return INewInputSystem.buttonPressedStates.TryGetValue(key, out value2) && value2;
		}

		public static bool WasButtonPressedThisFrame(string buttonPath)
		{
			if (!_isEnabled)
			{
				return false;
			}
			string key = buttonPath.ToLower();
			if (INewInputSystem.gamepadButtonControls.TryGetValue(key, out var value) && _buttonWasPressedProp != null)
			{
				_buttonWasPressedProp.GetValue(value, BindingFlags.Default, null, null, null);
			}
			bool value2;
			return INewInputSystem.buttonWasPressedStates.TryGetValue(key, out value2) && value2;
		}

		public static bool WasButtonReleasedThisFrame(string buttonPath)
		{
			if (!_isEnabled)
			{
				return false;
			}
			string key = buttonPath.ToLower();
			if (INewInputSystem.gamepadButtonControls.TryGetValue(key, out var value) && _buttonWasReleasedProp != null)
			{
				_buttonWasReleasedProp.GetValue(value, BindingFlags.Default, null, null, null);
			}
			bool value2;
			return INewInputSystem.buttonWasReleasedStates.TryGetValue(key, out value2) && value2;
		}

		public static float GetAxisValue(string axisPath)
		{
			if (!_isEnabled)
			{
				return 0f;
			}
			string key = NormalizeControlPath(axisPath ?? "");
			if (_axisControls.TryGetValue(key, out var value) && _axisReadValueMethod != null)
			{
				_axisReadValueMethod.Invoke(value, null);
			}
			float value2;
			return _axisValues.TryGetValue(key, out value2) ? value2 : 0f;
		}

		public static Vector2 GetVector2Value(string vectorPath)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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_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)
			if (!_isEnabled)
			{
				return new Vector2(0f, 0f);
			}
			string key = NormalizeControlPath(vectorPath ?? "");
			if (_vector2Controls.TryGetValue(key, out var value) && _vector2ReadValueMethod != null)
			{
				_vector2ReadValueMethod.Invoke(value, null);
			}
			Vector2 value2;
			return (Vector2)(_vector2Values.TryGetValue(key, out value2) ? value2 : new Vector2(0f, 0f));
		}

		public static IEnumerable<string> GetRegisteredButtonPaths()
		{
			return INewInputSystem.gamepadButtonControls.Keys;
		}

		public static IEnumerable<string> GetRegisteredAxisPaths()
		{
			return _axisControls.Keys;
		}

		public static IEnumerable<string> GetRegisteredVector2Paths()
		{
			return _vector2Controls.Keys;
		}

		private static void Postfix_Vector2ReadValue(object __instance, ref object __result)
		{
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			if (__instance == null || __result == null)
			{
				return;
			}
			try
			{
				if (_deviceProp != null)
				{
					object value = _deviceProp.GetValue(__instance, BindingFlags.Default, null, null, null);
					if (value == null)
					{
						return;
					}
				}
			}
			catch
			{
				return;
			}
			string text = ExtractAndNormalizePath(__instance);
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			try
			{
				if (_vector2XProp != null && _vector2YProp != null)
				{
					float num = (float)_vector2XProp.GetValue(__result, BindingFlags.Default, null, null, null);
					float num2 = (float)_vector2YProp.GetValue(__result, BindingFlags.Default, null, null, null);
					_vector2Values[text] = new Vector2(num, num2);
					if (_isEnabled && FreeCamPanel.ShouldOverrideInput() && _vector2XProp.CanWrite && _vector2YProp.CanWrite)
					{
						_vector2XProp.SetValue(__result, 0f, BindingFlags.Default, null, null, null);
						_vector2YProp.SetValue(__result, 0f, BindingFlags.Default, null, null, null);
					}
				}
			}
			catch
			{
			}
		}

		private static void Postfix_AxisReadValue(object __instance, ref float __result)
		{
			if (__instance == null)
			{
				return;
			}
			try
			{
				if (_deviceProp != null)
				{
					object value = _deviceProp.GetValue(__instance, BindingFlags.Default, null, null, null);
					if (value == null)
					{
						return;
					}
				}
			}
			catch
			{
				return;
			}
			string text = ExtractAndNormalizePath(__instance);
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			string text2 = text;
			try
			{
				object gamepadInstance = GetGamepadInstance(_targetGamepadIndex);
				if (gamepadInstance != null)
				{
					if (_gamepadLeftStickProp != null)
					{
						object value2 = _gamepadLeftStickProp.GetValue(gamepadInstance, BindingFlags.Default, null, null, null);
						if (value2 != null)
						{
							PropertyInfo property = value2.GetType().GetProperty("x", BindingFlags.Instance | BindingFlags.Public);
							PropertyInfo property2 = value2.GetType().GetProperty("y", BindingFlags.Instance | BindingFlags.Public);
							object obj2 = property?.GetValue(value2, BindingFlags.Default, null, null, null);
							object obj3 = property2?.GetValue(value2, BindingFlags.Default, null, null, null);
							if (__instance == obj2 || __instance == obj3)
							{
								text2 = text.Replace("/gamepad/x", "/gamepad/leftstick/x").Replace("/gamepad/y", "/gamepad/leftstick/y");
							}
						}
					}
					if (text2 == text && _gamepadRightStickProp != null)
					{
						object value3 = _gamepadRightStickProp.GetValue(gamepadInstance, BindingFlags.Default, null, null, null);
						if (value3 != null)
						{
							PropertyInfo property3 = value3.GetType().GetProperty("x", BindingFlags.Instance | BindingFlags.Public);
							PropertyInfo property4 = value3.GetType().GetProperty("y", BindingFlags.Instance | BindingFlags.Public);
							object obj4 = property3?.GetValue(value3, BindingFlags.Default, null, null, null);
							object obj5 = property4?.GetValue(value3, BindingFlags.Default, null, null, null);
							if (__instance == obj4 || __instance == obj5)
							{
								text2 = text.Replace("/gamepad/x", "/gamepad/rightstick/x").Replace("/gamepad/y", "/gamepad/rightstick/y");
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				ExplorerCore.LogWarning("[IGamepadInputInterceptor] Error identifying stick axis: " + ex.Message);
			}
			_axisValues[text2] = __result;
			if (_isEnabled && FreeCamPanel.ShouldOverrideInput())
			{
				__result = 0f;
			}
		}
	}
	public static class IInputManager
	{
		private static InputType currentInputType;

		public static Vector3 MousePosition => InputManager.MousePosition;

		public static void Setup()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected I4, but got Unknown
			currentInputType = InputManager.CurrentType;
			InputType val = currentInputType;
			InputType val2 = val;
			switch ((int)val2)
			{
			case 1:
				ILegacyInput.Init();
				break;
			case 0:
				INewInputSystem.Init();
				break;
			case 2:
				break;
			}
		}

		public static bool GetKey(KeyCode key)
		{
			//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_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected I4, but got Unknown
			//IL_0026: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			InputType val = currentInputType;
			InputType val2 = val;
			return (int)val2 switch
			{
				1 => ILegacyInput.GetKey(key), 
				0 => INewInputSystem.GetKey(key), 
				_ => InputManager.GetKey(key), 
			};
		}

		public unsafe static bool GetKeyDown(KeyCode key)
		{
			//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_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected I4, but got Unknown
			//IL_001d: 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)
			InputType val = currentInputType;
			InputType val2 = val;
			switch ((int)val2)
			{
			case 1:
				return ILegacyInput.GetKeyDown(key);
			case 0:
			{
				string buttonName = ("/keyboard/" + ((object)(*(KeyCode*)(&key))/*cast due to .constrained prefix*/).ToString()).ToLower();
				return INewInputSystem.GetButtonWasPressed(buttonName);
			}
			default:
				return InputManager.GetKeyDown(key);
			}
		}

		public unsafe static bool GetKeyUp(KeyCode key)
		{
			//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_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected I4, but got Unknown
			//IL_001d: 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)
			InputType val = currentInputType;
			InputType val2 = val;
			switch ((int)val2)
			{
			case 1:
				return ILegacyInput.GetKeyUp(key);
			case 0:
			{
				string buttonName = ("/keyboard/" + ((object)(*(KeyCode*)(&key))/*cast due to .constrained prefix*/).ToString()).ToLower();
				return INewInputSystem.GetButtonWasReleased(buttonName);
			}
			default:
				return InputManager.GetKeyUp(key);
			}
		}

		public static bool GetMouseButton(int button)
		{
			//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_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected I4, but got Unknown
			InputType val = currentInputType;
			InputType val2 = val;
			return (int)val2 switch
			{
				1 => ILegacyInput.GetMouseButton(button), 
				0 => INewInputSystem.GetMouseButton(button), 
				_ => InputManager.GetMouseButton(button), 
			};
		}

		public static bool GetMouseButtonDown(int button)
		{
			//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_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected I4, but got Unknown
			InputType val = currentInputType;
			InputType val2 = val;
			return (int)val2 switch
			{
				1 => ILegacyInput.GetMouseButtonDown(button), 
				0 => INewInputSystem.GetMouseButtonDown(button), 
				_ => InputManager.GetMouseButtonDown(button), 
			};
		}
	}
	public static class ILegacyInput
	{
		public static Dictionary<KeyCode, bool> getKeyDict = new Dictionary<KeyCode, bool>();

		public static Dictionary<KeyCode, bool> getKeyDownDict = new Dictionary<KeyCode, bool>();

		public static Dictionary<KeyCode, bool> getKeyUpDict = new Dictionary<KeyCode, bool>();

		public static Dictionary<int, bool> getMouseButton = new Dictionary<int, bool>();

		public static Dictionary<int, bool> getMouseButtonDown = new Dictionary<int, bool>();

		public static bool GetKey(KeyCode key)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_000d: 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 ((int)key == 0)
			{
				return false;
			}
			InputManager.GetKey(key);
			return getKeyDict[key];
		}

		public static bool GetKeyDown(KeyCode key)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_000d: 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 ((int)key == 0)
			{
				return false;
			}
			InputManager.GetKeyDown(key);
			return getKeyDownDict[key];
		}

		public static bool GetKeyUp(KeyCode key)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_000d: 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 ((int)key == 0)
			{
				return false;
			}
			InputManager.GetKeyUp(key);
			return getKeyUpDict[key];
		}

		public static bool GetMouseButton(int button)
		{
			InputManager.GetMouseButton(button);
			return getMouseButton[button];
		}

		public static bool GetMouseButtonDown(int button)
		{
			InputManager.GetMouseButtonDown(button);
			return getMouseButtonDown[button];
		}

		public static void Init()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Expected O, but got Unknown
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Expected O, but got Unknown
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Expected O, but got Unknown
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Expected O, but got Unknown
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Expected O, but got Unknown
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Expected O, but got Unknown
			Type typeByName = ReflectionUtility.GetTypeByName("UnityEngine.Input");
			try
			{
				MethodInfo method = typeByName.GetMethod("GetKey", new Type[1] { typeof(string) });
				if (Il2CppInteropUtils.GetIl2CppMethodInfoPointerFieldForGeneratedMethod((MethodBase)method) == null)
				{
					throw new Exception();
				}
				ExplorerCore.Harmony.Patch((MethodBase)method, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(ILegacyInput), "OverrideKeyString", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
			try
			{
				MethodInfo method2 = typeByName.GetMethod("GetKey", new Type[1] { typeof(KeyCode) });
				if (Il2CppInteropUtils.GetIl2CppMethodInfoPointerFieldForGeneratedMethod((MethodBase)method2) == null)
				{
					throw new Exception();
				}
				ExplorerCore.Harmony.Patch((MethodBase)method2, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(ILegacyInput), "OverrideKeyKeyCode", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
			try
			{
				MethodInfo method3 = typeByName.GetMethod("GetKeyDown", new Type[1] { typeof(string) });
				if (Il2CppInteropUtils.GetIl2CppMethodInfoPointerFieldForGeneratedMethod((MethodBase)method3) == null)
				{
					throw new Exception();
				}
				ExplorerCore.Harmony.Patch((MethodBase)method3, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(ILegacyInput), "OverrideKeyDownString", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
			try
			{
				MethodInfo method4 = typeByName.GetMethod("GetKeyDown", new Type[1] { typeof(KeyCode) });
				if (Il2CppInteropUtils.GetIl2CppMethodInfoPointerFieldForGeneratedMethod((MethodBase)method4) == null)
				{
					throw new Exception();
				}
				ExplorerCore.Harmony.Patch((MethodBase)method4, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(ILegacyInput), "OverrideKeyDownKeyCode", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
			try
			{
				MethodInfo method5 = typeByName.GetMethod("GetKeyUp", new Type[1] { typeof(string) });
				if (Il2CppInteropUtils.GetIl2CppMethodInfoPointerFieldForGeneratedMethod((MethodBase)method5) == null)
				{
					throw new Exception();
				}
				ExplorerCore.Harmony.Patch((MethodBase)method5, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(ILegacyInput), "OverrideKeyUpString", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
			try
			{
				MethodInfo method6 = typeByName.GetMethod("GetKeyUp", new Type[1] { typeof(KeyCode) });
				if (Il2CppInteropUtils.GetIl2CppMethodInfoPointerFieldForGeneratedMethod((MethodBase)method6) == null)
				{
					throw new Exception();
				}
				ExplorerCore.Harmony.Patch((MethodBase)method6, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(ILegacyInput), "OverrideKeyUpKeyCode", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
			try
			{
				MethodInfo method7 = typeByName.GetMethod("GetMouseButton", new Type[1] { typeof(int) });
				if (Il2CppInteropUtils.GetIl2CppMethodInfoPointerFieldForGeneratedMethod((MethodBase)method7) == null)
				{
					throw new Exception();
				}
				ExplorerCore.Harmony.Patch((MethodBase)method7, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(ILegacyInput), "OverrideMouseButton", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
			try
			{
				MethodInfo method8 = typeByName.GetMethod("GetMouseButtonDown", new Type[1] { typeof(int) });
				if (Il2CppInteropUtils.GetIl2CppMethodInfoPointerFieldForGeneratedMethod((MethodBase)method8) == null)
				{
					throw new Exception();
				}
				ExplorerCore.Harmony.Patch((MethodBase)method8, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(ILegacyInput), "OverrideMouseButtonDown", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
		}

		public static void OverrideKeyString(ref bool __result, ref string name)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			KeyCode key = (KeyCode)System.Enum.Parse(typeof(KeyCode), name);
			getKeyDict[key] = __result;
			if (FreeCamPanel.ShouldOverrideInput())
			{
				__result = false;
			}
		}

		public static void OverrideKeyKeyCode(ref bool __result, ref KeyCode key)
		{
			if (key)
			{
				getKeyDict[key] = __result;
				if (FreeCamPanel.ShouldOverrideInput())
				{
					__result = false;
				}
			}
		}

		public static void OverrideKeyDownString(ref bool __result, ref string name)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			KeyCode key = (KeyCode)System.Enum.Parse(typeof(KeyCode), name);
			getKeyDownDict[key] = __result;
			if (FreeCamPanel.ShouldOverrideInput())
			{
				__result = false;
			}
		}

		public static void OverrideKeyDownKeyCode(ref bool __result, ref KeyCode key)
		{
			if (key)
			{
				getKeyDownDict[key] = __result;
				if (FreeCamPanel.ShouldOverrideInput())
				{
					__result = false;
				}
			}
		}

		public static void OverrideKeyUpString(ref bool __result, ref string name)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			KeyCode key = (KeyCode)System.Enum.Parse(typeof(KeyCode), name);
			getKeyUpDict[key] = __result;
			if (FreeCamPanel.ShouldOverrideInput())
			{
				__result = false;
			}
		}

		public static void OverrideKeyUpKeyCode(ref bool __result, ref KeyCode key)
		{
			if (key)
			{
				getKeyUpDict[key] = __result;
				if (FreeCamPanel.ShouldOverrideInput())
				{
					__result = false;
				}
			}
		}

		public static void OverrideMouseButton(ref bool __result, ref int button)
		{
			getMouseButton[button] = __result;
			if (FreeCamPanel.ShouldOverrideInput() && (button != 0 || !UIManager.ShowMenu))
			{
				__result = false;
			}
		}

		public static void OverrideMouseButtonDown(ref bool __result, ref int button)
		{
			getMouseButtonDown[button] = __result;
			if (FreeCamPanel.ShouldOverrideInput() && (button != 0 || !UIManager.ShowMenu))
			{
				__result = false;
			}
		}
	}
	public static class INewInputSystem
	{
		private static PropertyInfo isPressedProp;

		private static PropertyInfo wasPressedProp;

		private static PropertyInfo wasReleasedProp;

		private static MethodInfo isValueConsideredPressed;

		private static MethodInfo isPressedMethod;

		private static MethodInfo isInProgressMethod;

		private static MethodInfo wasPressedMethod;

		private static MethodInfo wasPerformedMethod;

		internal static readonly Dictionary<string, object> buttonControls = new Dictionary<string, object>();

		internal static readonly Dictionary<string, object> gamepadButtonControls = new Dictionary<string, object>();

		internal static readonly Dictionary<string, bool> buttonPressedStates = new Dictionary<string, bool>();

		internal static readonly Dictionary<string, bool> buttonWasPressedStates = new Dictionary<string, bool>();

		internal static readonly Dictionary<string, bool> buttonWasReleasedStates = new Dictionary<string, bool>();

		private static readonly Dictionary<string, bool> buttonIsValueConsideredPressedStates = new Dictionary<string, bool>();

		private static readonly Dictionary<string, bool> actionInProgressStates = new Dictionary<string, bool>();

		private static readonly Dictionary<string, bool> actionWasPerformedStates = new Dictionary<string, bool>();

		public static void Init()
		{
			Type typeByName = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Controls.ButtonControl, Unity.InputSystem");
			Type typeByName2 = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.InputAction, Unity.InputSystem");
			if (typeByName == null || typeByName2 == null)
			{
				ExplorerCore.LogWarning("Unity.InputSystem types not found; InputSystem integration disabled.");
				return;
			}
			PatchButtonControl(typeByName);
			PatchInputAction(typeByName2);
			GetButtonControls();
			IGamepadInputInterceptor.Init();
		}

		private static void PatchButtonControl(Type buttonControlType)
		{
			isPressedProp = buttonControlType.GetProperty("isPressed");
			wasPressedProp = buttonControlType.GetProperty("wasPressedThisFrame");
			wasReleasedProp = buttonControlType.GetProperty("wasReleasedThisFrame");
			isValueConsideredPressed = buttonControlType.GetMethod("IsValueConsideredPressed");
			PatchPropertyGetter(isPressedProp, "Postfix_IsPressed");
			PatchPropertyGetter(wasPressedProp, "Postfix_WasPressedThisFrame");
			PatchPropertyGetter(wasReleasedProp, "Postfix_WasReleasedThisFrame");
			PatchPropertyGetter(wasReleasedProp, "Postfix_IsValueConsideredPressed");
		}

		private static void PatchInputAction(Type inputActionType)
		{
			isPressedMethod = inputActionType.GetMethod("IsPressed");
			isInProgressMethod = inputActionType.GetMethod("IsInProgress");
			wasPressedMethod = inputActionType.GetMethod("WasPressedThisFrame");
			wasPerformedMethod = inputActionType.GetMethod("WasPerformedThisFrame");
			PatchMethod(isPressedMethod, "Postfix_IsPressed");
			PatchMethod(isInProgressMethod, "Postfix_IsInProgress");
			PatchMethod(wasPressedMethod, "Postfix_WasPressedThisFrame");
			PatchMethod(wasPerformedMethod, "Postfix_WasPerformedThisFrame");
		}

		private static void PatchPropertyGetter(PropertyInfo prop, string postfixName)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			if (!(prop?.GetGetMethod() == null))
			{
				if (Il2CppInteropUtils.GetIl2CppMethodInfoPointerFieldForGeneratedMethod((MethodBase)prop.GetGetMethod()) == null)
				{
					throw new Exception();
				}
				ExplorerCore.Harmony.Patch((MethodBase)prop.GetGetMethod(), (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(INewInputSystem), postfixName, (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		private static void PatchMethod(MethodInfo method, string postfixName)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			if (!(method == null))
			{
				if (Il2CppInteropUtils.GetIl2CppMethodInfoPointerFieldForGeneratedMethod((MethodBase)method) == null)
				{
					throw new Exception();
				}
				ExplorerCore.Harmony.Patch((MethodBase)method, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(INewInputSystem), postfixName, (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		public static void GetButtonControls()
		{
			PropertyInfo pathProp = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Controls.ButtonControl, Unity.InputSystem")?.GetProperty("path", BindingFlags.Instance | BindingFlags.Public);
			RegisterDeviceControls("UnityEngine.InputSystem.Keyboard", "UnityEngine.InputSystem.Controls.KeyControl", pathProp);
			RegisterDeviceControls("UnityEngine.InputSystem.Mouse", "UnityEngine.InputSystem.Controls.ButtonControl", pathProp);
		}

		internal static void RegisterDeviceControls(string deviceTypeName, string controlTypeName, PropertyInfo pathProp)
		{
			Type typeByName = ReflectionUtility.GetTypeByName(deviceTypeName + ", Unity.InputSystem");
			if (typeByName == null)
			{
				return;
			}
			object obj = typeByName.GetProperty("current", BindingFlags.Static | BindingFlags.Public)?.GetValue(null, null);
			if (obj == null)
			{
				return;
			}
			PropertyInfo[] properties = typeByName.GetProperties(BindingFlags.Instance | BindingFlags.Public);
			foreach (PropertyInfo propertyInfo in properties)
			{
				if (propertyInfo.GetIndexParameters().Length != 0 || !(propertyInfo.PropertyType.FullName == controlTypeName))
				{
					continue;
				}
				object value = propertyInfo.GetValue(obj, null);
				if (value != null)
				{
					string text = pathProp?.GetValue(value, null) as string;
					if (!string.IsNullOrEmpty(text))
					{
						buttonControls[text.ToLower()] = value;
					}
				}
			}
		}

		public unsafe static bool GetKey(KeyCode key)
		{
			string buttonName = PropToKeycode(("/keyboard/" + ((object)(*(KeyCode*)(&key))/*cast due to .constrained prefix*/).ToString()).ToLower());
			return GetButtonPressed(buttonName);
		}

		public static bool GetButtonPressed(string buttonName)
		{
			string key = buttonName.ToLower();
			if (buttonControls.TryGetValue(key, out var value))
			{
				isPressedProp?.GetValue(value, null);
				bool value2;
				return buttonPressedStates.TryGetValue(key, out value2) && value2;
			}
			return false;
		}

		public static bool GetButtonWasPressed(string buttonName)
		{
			string key = buttonName.ToLower();
			if (buttonControls.TryGetValue(key, out var value))
			{
				wasPressedProp?.GetValue(value, null);
				bool value2;
				return buttonWasPressedStates.TryGetValue(key, out value2) && value2;
			}
			return false;
		}

		public static bool GetButtonWasReleased(string buttonName)
		{
			string key = buttonName.ToLower();
			if (buttonControls.TryGetValue(key, out var value))
			{
				wasReleasedProp?.GetValue(value, null);
				bool value2;
				return buttonWasReleasedStates.TryGetValue(key, out value2) && value2;
			}
			return false;
		}

		public static bool GetMouseButton(int button)
		{
			return GetButtonPressed(button switch
			{
				0 => "/mouse/leftbutton", 
				1 => "/mouse/rightbutton", 
				2 => "/mouse/middlebutton", 
				3 => "/mouse/forwardbutton", 
				4 => "/mouse/backbutton", 
				_ => $"/mouse/button{button}", 
			});
		}

		public static bool GetMouseButtonDown(int button)
		{
			return GetButtonWasPressed(button switch
			{
				0 => "/mouse/leftbutton", 
				1 => "/mouse/rightbutton", 
				2 => "/mouse/middlebutton", 
				3 => "/mouse/forwardbutton", 
				4 => "/mouse/backbutton", 
				_ => $"/mouse/button{button}", 
			});
		}

		private static void Postfix_IsPressed(object __instance, ref bool __result)
		{
			StoreState(__instance, ref __result, buttonPressedStates);
		}

		private static void Postfix_WasPressedThisFrame(object __instance, ref bool __result)
		{
			StoreState(__instance, ref __result, buttonWasPressedStates);
		}

		private static void Postfix_WasReleasedThisFrame(object __instance, ref bool __result)
		{
			StoreState(__instance, ref __result, buttonWasReleasedStates);
		}

		private static void Postfix_IsValueConsideredPressed(object __instance, ref bool __result)
		{
			StoreState(__instance, ref __result, buttonIsValueConsideredPressedStates);
		}

		private static void Postfix_IsInProgress(object __instance, ref bool __result)
		{
			StoreState(__instance, ref __result, actionInProgressStates);
		}

		private static void Postfix_WasPerformedThisFrame(object __instance, ref bool __result)
		{
			StoreState(__instance, ref __result, actionWasPerformedStates);
		}

		private static void StoreState(object __instance, ref bool __result, Dictionary<string, bool> dict)
		{
			try
			{
				Type type = __instance.GetType();
				string rawPath = ((type.GetProperty("path") ?? type.GetProperty("name"))?.GetValue(__instance, null)?.ToString() ?? string.Empty).ToLower();
				rawPath = IGamepadInputInterceptor.NormalizeControlPath(rawPath);
				dict[rawPath] = __result;
				if (FreeCamPanel.ShouldOverrideInput())
				{
					__result = false;
				}
			}
			catch (Exception ex)
			{
				ExplorerCore.LogWarning("Failed to store state: " + ex.Message);
			}
		}

		public static string PropToKeycode(string propName)
		{
			return propName switch
			{
				"/keyboard/leftcontrol" => "/keyboard/leftctrl", 
				"/keyboard/rightcontrol" => "/keyboard/rightctrl", 
				"/keyboard/keypad0" => "/keyboard/numpad0", 
				"/keyboard/keypad1" => "/keyboard/numpad1", 
				"/keyboard/keypad2" => "/keyboard/numpad2", 
				"/keyboard/keypad3" => "/keyboard/numpad3", 
				"/keyboard/keypad4" => "/keyboard/numpad4", 
				"/keyboard/keypad5" => "/keyboard/numpad5", 
				"/keyboard/keypad6" => "/keyboard/numpad6", 
				"/keyboard/keypad7" => "/keyboard/numpad7", 
				"/keyboard/keypad8" => "/keyboard/numpad8", 
				"/keyboard/keypad9" => "/keyboard/numpad9", 
				"/keyboard/keypaddivide" => "/keyboard/numpaddivide", 
				"/keyboard/keypadmultiply" => "/keyboard/numpadmultiply", 
				"/keyboard/keypadminus" => "/keyboard/numpadminus", 
				"/keyboard/keypadplus" => "/keyboard/numpadplus", 
				"/keyboard/keypadperiod" => "/keyboard/numpadperiod", 
				"/keyboard/keypadequals" => "/keyboard/numpadequals", 
				"/keyboard/keypadenter" => "/keyboard/numpadenter", 
				"/keyboard/alpha0" => "/keyboard/0", 
				"/keyboard/alpha1" => "/keyboard/1", 
				"/keyboard/alpha2" => "/keyboard/2", 
				"/keyboard/alpha3" => "/keyboard/3", 
				"/keyboard/alpha4" => "/keyboard/4", 
				"/keyboard/alpha5" => "/keyboard/5", 
				"/keyboard/alpha6" => "/keyboard/6", 
				"/keyboard/alpha7" => "/keyboard/7", 
				"/keyboard/alpha8" => "/keyboard/8", 
				"/keyboard/alpha9" => "/keyboard/9", 
				"/keyboard/print" => "/keyboard/printscreen", 
				_ => propName, 
			};
		}
	}
}
namespace UnityExplorer
{
	public class ArrowGenerator
	{
		public static GameObject CreateArrow(Vector3 arrowPosition, Quaternion arrowRotation, Color color)
		{
			//IL_01bd: 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_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: 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_009e: Expected O, but got Unknown
			//IL_00a5: 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: Expected O, but got Unknown
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Expected O, but got Unknown
			//IL_0164: 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_0180: 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_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				float value = ConfigManager.Arrow_Size.Value;
				Vector3 localScale = default(Vector3);
				((Vector3)(ref localScale))..ctor(Math.Max(value, 0.1f), Math.Max(value, 0.1f), Math.Max(value, 0.1f));
				GameObject val = GameObject.CreatePrimitive((PrimitiveType)2);
				val.GetComponent<Collider>().enabled = false;
				val.GetComponent<MeshFilter>().mesh = CreateCylinderMesh(0.01f, 20, 2);
				val.transform.rotation = Quaternion.LookRotation(Vector3.down, Vector3.up);
				Renderer component = val.GetComponent<Renderer>();
				component.material = new Material(Shader.Find("Sprites/Default"));
				component.material.color = color;
				GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)0);
				val2.GetComponent<Collider>().enabled = false;
				val2.GetComponent<MeshFilter>().mesh = CreateConeMesh(10, 0.05f, 0.1f);
				val2.transform.SetParent(val.transform, true);
				Renderer component2 = val2.GetComponent<Renderer>();
				component2.material = new Material(Shader.Find("Sprites/Default"));
				component2.material.color = color;
				val.transform.rotation = Quaternion.LookRotation(Vector3.back, Vector3.up);
				GameObject val3 = new GameObject("CUE-Arrow");
				val.transform.SetParent(val3.transform, true);
				val3.transform.localScale = localScale;
				val3.transform.position = arrowPosition;
				val3.transform.rotation = arrowRotation;
				Transform transform = val3.transform;
				transform.position += 0.5f * val3.transform.forward;
				return val3;
			}
			catch
			{
				return FallbackArrow(arrowPosition, arrowRotation, color);
			}
		}

		private static GameObject FallbackArrow(Vector3 arrowPosition, Quaternion arrowRotation, Color color)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_0038: 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_0088: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_00e9: 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_00fc: Expected O, but got Unknown
			//IL_0117: 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_013e: 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_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.CreatePrimitive((PrimitiveType)2);
			val.GetComponent<Collider>().enabled = false;
			Renderer component = val.GetComponent<Renderer>();
			component.material = new Material(Shader.Find("Sprites/Default"));
			component.material.color = color;
			val.transform.localScale = new Vector3(0.025f, 0.15f, 0.025f);
			GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)0);
			val2.GetComponent<Collider>().enabled = false;
			val2.transform.localScale = new Vector3(0.05f, 0.05f, 0.05f);
			val2.transform.position = new Vector3(0f, 0.15f, 0f);
			val2.transform.SetParent(val.transform, true);
			Renderer component2 = val2.GetComponent<Renderer>();
			component2.material = new Material(Shader.Find("Sprites/Default"));
			component2.material.color = color;
			GameObject val3 = new GameObject("CUE-Arrow");
			val.transform.SetParent(val3.transform, true);
			val3.transform.position = arrowPosition;
			Vector3 eulerAngles = ((Quaternion)(ref arrowRotation)).eulerAngles;
			eulerAngles.x += 90f;
			val3.transform.rotation = Quaternion.Euler(eulerAngles);
			Transform transform = val3.transform;
			transform.position += 0.15f * val3.transform.up;
			return val3;
		}

		public static void PatchLights()
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			try
			{
				PropertyInfo property = typeof(Light).GetProperty("color");
				MethodInfo setMethod = property.GetSetMethod();
				if (!(Il2CppInteropUtils.GetIl2CppMethodInfoPointerFieldForGeneratedMethod((MethodBase)setMethod) == null))
				{
					ExplorerCore.Harmony.Patch((MethodBase)setMethod, new HarmonyMethod(AccessTools.Method(typeof(ArrowGenerator), "ChangeArrowColor", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
			catch
			{
			}
		}

		private static void ChangeArrowColor(Light __instance, Color __0)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (((Object)__instance).name.Contains("CUE - Light"))
			{
				Renderer[] array = Il2CppArrayBase<Renderer>.op_Implicit(((Component)__instance).GetComponentsInChildren<Renderer>());
				Renderer[] array2 = array;
				foreach (Renderer val in array2)
				{
					val.material.color = __0;
				}
			}
		}

		private static Mesh CreateConeMesh(int subdivisions, float radius, float height)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//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_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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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)
			Mesh val = new Mesh();
			Vector3[] array = (Vector3[])(object)new Vector3[subdivisions + 2];
			Vector2[] array2 = (Vector2[])(object)new Vector2[array.Length];
			int[] array3 = new int[subdivisions * 2 * 3];
			array[0] = Vector3.zero;
			array2[0] = new Vector2(0.5f, 0f);
			int i = 0;
			int num = subdivisions - 1;
			for (; i < subdivisions; i++)
			{
				float num2 = (float)i / (float)num;
				float num3 = num2 * (MathF.PI * 2f);
				float num4 = Mathf.Cos(num3) * radius;
				float num5 = Mathf.Sin(num3) * radius;
				array[i + 1] = new Vector3(num4, 0f, num5);
				array2[i + 1] = new Vector2(num2, 0f);
			}
			array[subdivisions + 1] = new Vector3(0f, height, 0f);
			array2[subdivisions + 1] = new Vector2(0.5f, 1f);
			int j = 0;
			for (int num6 = subdivisions - 1; j < num6; j++)
			{
				int num7 = j * 3;
				array3[num7] = 0;
				array3[num7 + 1] = j + 1;
				array3[num7 + 2] = j + 2;
			}
			int num8 = subdivisions * 3;
			int k = 0;
			for (int num9 = subdivisions - 1; k < num9; k++)
			{
				int num10 = k * 3 + num8;
				array3[num10] = k + 1;
				array3[num10 + 1] = subdivisions + 1;
				array3[num10 + 2] = k + 2;
			}
			val.vertices = Il2CppStructArray<Vector3>.op_Implicit(array);
			val.uv = Il2CppStructArray<Vector2>.op_Implicit(array2);
			val.triangles = Il2CppStructArray<int>.op_Implicit(array3);
			val.RecalculateBounds();
			val.RecalculateNormals();
			return val;
		}

		private static Mesh CreateCylinderMesh(float radius = 1f, int iterations = 50, int lenggth = 10, float gap = 0.5f)
		{
			//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_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_00dc: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			int num = 0;
			float num2 = 0f;
			int i = 0;
			Vector3[] array = (Vector3[])(object)new Vector3[iterations * lenggth + 2];
			int num3 = 0;
			array[^2] = Vector3.zero;
			for (; i < lenggth; i++)
			{
				int num4 = 0;
				while (num4 < iterations)
				{
					float num5 = (float)num4 * 1f / (float)iterations * MathF.PI * 2f;
					float num6 = Mathf.Sin(num5) * radius;
					float num7 = Mathf.Cos(num5) * radius;
					array[num3] = new Vector3(num6, num7, num2);
					num4++;
					num++;
					num3++;
				}
				num2 += gap;
			}
			array[^1] = new Vector3(0f, 0f, array[^3].z);
			Mesh val = new Mesh();
			val.vertices = Il2CppStructArray<Vector3>.op_Implicit(array);
			int j = 0;
			Vector3[] array2 = (Vector3[])(object)new Vector3[num + 2];
			for (; j < num; j++)
			{
				array2[j] = Vector3.forward;
			}
			val.normals = Il2CppStructArray<Vector3>.op_Implicit(array2);
			j = 0;
			int[] array3 = new int[3 * (lenggth - 1) * iterations * 2 + 3];
			for (; j < (lenggth - 1) * iterations; j++)
			{
				array3[j * 3] = j;
				if ((j + 1) % iterations == 0)
				{
					array3[j * 3 + 1] = 1 + j - iterations;
				}
				else
				{
					array3[j * 3 + 1] = 1 + j;
				}
				array3[j * 3 + 2] = iterations + j;
			}
			int num8 = -1;
			for (int k = (array3.Length - 3) / 2; k < array3.Length - 6; k += 3)
			{
				if ((num8 + 2) % iterations == 0)
				{
					array3[k] = num8 + iterations * 2 + 1;
				}
				else
				{
					array3[k] = num8 + iterations + 1;
				}
				array3[k + 1] = num8 + 2;
				array3[k + 2] = num8 + iterations + 2;
				num8++;
			}
			array3[^3] = 0;
			array3[^2] = iterations * 2 - 1;
			array3[^1] = iterations;
			int[] array4 = new int[iterations * 3 * 2];
			int num9 = 0;
			for (int l = 0; l < array4.Length / 2; l += 3)
			{
				array4[l] = num9;
				if (num9 + 1 != iterations)
				{
					array4[l + 1] = num9 + 1;
				}
				else
				{
					array4[l + 1] = 0;
				}
				array4[l + 2] = array.Length - 2;
				num9++;
			}
			num9 = iterations * (lenggth - 1);
			for (int m = array4.Length / 2; m < array4.Length; m += 3)
			{
				array4[m] = num9;
				if (num9 + 1 != iterations * (lenggth - 1))
				{
					array4[m + 1] = num9 + 1;
				}
				else
				{
					array4[m + 1] = iterations * (lenggth - 1);
				}
				array4[m + 2] = array.Length - 1;
				num9++;
			}
			array4[^3] = iterations * (lenggth - 1);
			array4[^2] = array.Length - 3;
			array4[^1] = array.Length - 1;
			int[] array5 = new int[array3.Length + array4.Length];
			int num10 = 0;
			int num11 = 0;
			num10 = 0;
			num11 = 0;
			for (; num10 < array3.Length; num10++)
			{
				array5[num11++] = array3[num10];
			}
			for (num10 = 0; num10 < array4.Length; num10++)
			{
				array5[num11++] = array4[num10];
			}
			val.triangles = Il2CppStructArray<int>.op_Implicit(array5);
			val.Optimize();
			val.RecalculateNormals();
			return val;
		}
	}
	public class ExplorerBehaviour : MonoBehaviour
	{
		internal bool quitting;

		internal static ExplorerBehaviour Instance { get; private set; }

		public ExplorerBehaviour(IntPtr ptr)
			: base(ptr)
		{
		}

		internal static void Setup()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			ClassInjector.RegisterTypeInIl2Cpp<ExplorerBehaviour>();
			GameObject val = new GameObject("ExplorerBehaviour");
			Object.DontDestroyOnLoad((Object)(object)val);
			((Object)val).hideFlags = (HideFlags)61;
			Instance = val.AddComponent<ExplorerBehaviour>();
		}

		internal void Update()
		{
			ExplorerCore.Update();
		}

		internal void OnDestroy()
		{
			OnApplicationQuit();
		}

		internal void OnApplicationQuit()
		{
			if (!quitting)
			{
				quitting = true;
				if (Object.op_Implicit((Object)(object)UIManager.UIRoot))
				{
					TryDestroy(((Component)UIManager.UIRoot.transform.root).gameObject);
				}
				object? value = typeof(Universe).Assembly.GetType("UniverseLib.UniversalBehaviour").GetProperty("Instance", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null, null);
				TryDestroy(((Component)((value is Component) ? value : null)).gameObject);
				TryDestroy(((Component)this).gameObject);
			}
		}

		internal void TryDestroy(GameObject obj)
		{
			try
			{
				if (Object.op_Implicit((Object)(object)obj))
				{
					Object.Destroy((Object)(object)obj);
				}
			}
			catch
			{
			}
		}
	}
	public class KeypressListener : MonoBehaviour
	{
		private bool frameSkip;

		internal static KeypressListener Instance { get; private set; }

		public KeypressListener(IntPtr ptr)
			: base(ptr)
		{
		}

		internal static void Setup()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			ClassInjector.RegisterTypeInIl2Cpp<KeypressListener>();
			GameObject val = new GameObject("KeypressListener");
			Object.DontDestroyOnLoad((Object)(object)val);
			((Object)val).hideFlags = (HideFlags)61;
			Instance = val.AddComponent<KeypressListener>();
		}

		public void Update()
		{
			//IL_001b: 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_0076: 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_00be: 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_010a: 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)
			stopFrameSkip();
			maybeForcePause();
			maybeTakeScreenshot();
			if (IInputManager.GetKeyDown(ConfigManager.Pause.Value))
			{
				UIManager.GetTimeScaleWidget().PauseToggle();
			}
			if (IInputManager.GetKeyDown(ConfigManager.Frameskip.Value) && UIManager.GetTimeScaleWidget().IsPaused())
			{
				UIManager.GetTimeScaleWidget().PauseToggle();
				frameSkip = true;
			}
			if (IInputManager.GetKeyDown(ConfigManager.Screenshot.Value))
			{
				UIManager.GetPanel<Misc>(UIManager.Panels.Misc).screenshotStatus = Misc.ScreenshotState.TurnOffUI;
			}
			if (IInputManager.GetKeyDown(ConfigManager.HUD_Toggle.Value))
			{
				UIManager.GetPanel<Misc>(UIManager.Panels.Misc).ToggleHUDElements();
			}
			if (IInputManager.GetKeyDown(ConfigManager.Freecam_Toggle.Value))
			{
				FreeCamPanel.ToggleFreecam();
			}
			if (IInputManager.GetKeyDown(ConfigManager.Block_Freecam_Movement.Value))
			{
				FreeCamPanel.blockFreecamMovementToggle.isOn = !FreeCamPanel.blockFreecamMovementToggle.isOn;
			}
			if (IInputManager.GetKeyDown(ConfigManager.Toggle_Animations.Value))
			{
				UIManager.GetPanel<AnimatorPanel>(UIManager.Panels.AnimatorPanel).HotkeyToggleAnimators();
			}
			if (FreeCamPanel.supportedInput && IInputManager.GetKeyDown(ConfigManager.Toggle_Block_Games_Input.Value))
			{
				FreeCamPanel.blockGamesInputOnFreecamToggle.isOn = !FreeCamPanel.blockGamesInputOnFreecamToggle.isOn;
			}
			bool flag = IGamepadInputInterceptor.IsButtonPressed("/gamepad/buttonwest");
			bool flag2 = IGamepadInputInterceptor.IsButtonPressed("/gamepad/leftstickpress");
			bool flag3 = IGamepadInputInterceptor.IsButtonPressed("/gamepad/rightstickpress");
			if (flag && flag2)
			{
				if (IGamepadInputInterceptor.WasButtonPressedThisFrame("/gamepad/buttonwest") || IGamepadInputInterceptor.WasButtonPressedThisFrame("/gamepad/leftstickpress"))
				{
					UIManager.GetTimeScaleWidget().ToggleOverride();
				}
			}
			else if (flag && flag3 && (IGamepadInputInterceptor.WasButtonPressedThisFrame("/gamepad/buttonwest") || IGamepadInputInterceptor.WasButtonPressedThisFrame("/gamepad/rightstickpress")))
			{
				FreeCamPanel.ToggleFreecam();
			}
		}

		private void stopFrameSkip()
		{
			if (frameSkip && !UIManager.GetTimeScaleWidget().IsPaused())
			{
				frameSkip = false;
				UIManager.GetTimeScaleWidget().PauseToggle();
			}
		}

		private void maybeForcePause()
		{
			TimeScaleWidget timeScaleWidget = UIManager.GetTimeScaleWidget();
			if (timeScaleWidget != null && timeScaleWidget.IsPaused() && Time.timeScale != 0f)
			{
				timeScaleWidget.SetTimeScale(0f);
			}
		}

		private void maybeTakeScreenshot()
		{
			UIManager.GetPanel<Misc>(UIManager.Panels.Misc)?.MaybeTakeScreenshot();
		}
	}
	public static class ExplorerCore
	{
		public const string NAME = "CinematicUnityExplorer";

		public const string VERSION = "1.4.0";

		public const string AUTHOR = "originalnicodr, Sinai, yukieiji";

		public const string GUID = "com.originalnicodr.cinematicunityexplorer";

		public const string DEFAULT_EXPLORER_FOLDER_NAME = "CinematicUnityExplorer";

		public static IExplorerLoader Loader { get; private set; }

		public static string ExplorerFolder => Path.Combine(Loader.ExplorerFolderDestination, Loader.ExplorerFolderName);

		public static Harmony Harmony { get; } = new Harmony("com.originalnicodr.cinematicunityexplorer");

		public static void Init(IExplorerLoader loader)
		{
			//IL_006f: 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)
			if (Loader != null)
			{
				throw new Exception("CinematicUnityExplorer is already loaded.");
			}
			Loader = loader;
			Log("CinematicUnityExplorer 1.4.0 initializing...");
			CheckLegacyExplorerFolder();
			Directory.CreateDirectory(ExplorerFolder);
			ConfigManager.Init(Loader.ConfigHandler);
			Universe.Init(ConfigManager.Startup_Delay_Time.Value, (Action)LateInit, (Action<string, LogType>)Log, new UniverseLibConfig
			{
				Disable_EventSystem_Override = ConfigManager.Disable_EventSystem_Override.Value,
				Force_Unlock_Mouse = ConfigManager.Force_Unlock_Mouse.Value,
				Unhollowed_Modules_Folder = loader.UnhollowedModulesFolder
			});
			UERuntimeHelper.Init();
			ExplorerBehaviour.Setup();
			UnityCrashPrevention.Init();
			ArrowGenerator.PatchLights();
		}

		private static void LateInit()
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			SceneHandler.Init();
			Log("Creating UI...");
			UIManager.InitUI();
			Log($"{"CinematicUnityExplorer"} {"1.4.0"} ({Universe.Context}) initialized.");
			IInputManager.Setup();
			KeypressListener.Setup();
			if (ConfigManager.Auto_Scale_UI.Value)
			{
				MakeUEUIScale();
			}
		}

		internal static void Update()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (IInputManager.GetKeyDown(ConfigManager.Master_Toggle.Value))
			{
				UIManager.ShowMenu = !UIManager.ShowMenu;
			}
		}

		public static void Log(object message)
		{
			Log(message, (LogType)3);
		}

		public static void LogWarning(object message)
		{
			Log(message, (LogType)2);
		}

		public static void LogError(object message)
		{
			Log(message, (LogType)0);
		}

		public static void LogUnity(object message, LogType logType)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (ConfigManager.Log_Unity_Debug.Value)
			{
				Log($"[Unity] {message}", logType);
			}
		}

		private static void Log(object message, LogType logType)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected I4, but got Unknown
			string text = message?.ToString() ?? "";
			LogPanel.Log(text, logType);
			switch ((int)logType)
			{
			case 1:
			case 3:
				Loader.OnLogMessage(text);
				break;
			case 2:
				Loader.OnLogWarning(text);
				break;
			case 0:
			case 4:
				Loader.OnLogError(text);
				break;
			}
		}

		private static void CheckLegacyExplorerFolder()
		{
			string text = Path.Combine(Loader.ExplorerFolderDestination, "UnityExplorer");
			if (!Directory.Exists(text))
			{
				return;
			}
			LogWarning("Attempting to migrate old 'UnityExplorer/' folder to 'CinematicUnityExplorer/'...");
			if (!Directory.Exists(ExplorerFolder))
			{
				try
				{
					Directory.Move(text, ExplorerFolder);
					Log("Migrated successfully.");
					return;
				}
				catch (Exception value)
				{
					LogWarning($"Exception migrating folder: {value}");
					return;
				}
			}
			try
			{
				CopyAll(new DirectoryInfo(text), new DirectoryInfo(ExplorerFolder));
				Directory.Delete(text, recursive: true);
				Log("Migrated successfully.");
			}
			catch (Exception value2)
			{
				LogWarning($"Exception migrating folder: {value2}");
			}
		}

		public static void CopyAll(DirectoryInfo source, DirectoryInfo target)
		{
			Directory.CreateDirectory(target.FullName);
			FileInfo[] files = source.GetFiles();
			foreach (FileInfo fileInfo in files)
			{
				fileInfo.MoveTo(Path.Combine(target.ToString(), fileInfo.Name));
			}
			DirectoryInfo[] directories = source.GetDirectories();
			foreach (DirectoryInfo directoryInfo in directories)
			{
				DirectoryInfo target2 = target.CreateSubdirectory(directoryInfo.Name);
				CopyAll(directoryInfo, target2);
			}
		}

		private static void MakeUEUIScale()
		{
			List<CanvasScaler> list = (from obj in RuntimeHelper.FindObjectsOfTypeAll(typeof(CanvasScaler))
				select ((Il2CppObjectBase)obj).TryCast<CanvasScaler>() into c
				where ((Object)c).name.Contains("unityexplorer")
				select c).ToList();
			foreach (CanvasScaler item in list)
			{
				item.uiScaleMode = (ScaleMode)1;
				item.screenMatchMode = (ScreenMatchMode)0;
				item.matchWidthOrHeight = 0f;
			}
		}
	}
	public static class InspectorManager
	{
		public static readonly List<InspectorBase> Inspectors = new List<InspectorBase>();

		private static InspectorBase lastActiveInspector;

		public static float PanelWidth;

		public static InspectorBase ActiveInspector { get; private set; }

		public static event Action OnInspectedTabsChanged;

		public static void Inspect(object obj, CacheObjectBase parent = null)
		{
			if (UnityHelpers.IsNullOrDestroyed(obj, true))
			{
				return;
			}
			obj = ReflectionExtensions.TryCast(obj);
			if (!TryFocusActiveInspector(obj))
			{
				if ((Object)(object)ReflectionExtensions.TryCast<GameObject>(obj) != (Object)null)
				{
					CreateInspector<GameObjectInspector>(obj);
				}
				else
				{
					CreateInspector<ReflectionInspector>(obj, staticReflection: false, parent);
				}
			}
		}

		public static void Inspect(Type type)
		{
			if (!TryFocusActiveInspector(type))
			{
				CreateInspector<ReflectionInspector>(type, staticReflection: true);
			}
		}

		private static bool TryFocusActiveInspector(object target)
		{
			foreach (InspectorBase inspector in Inspectors)
			{
				bool flag = false;
				if (target is Type type)
				{
					if (inspector.TargetType.FullName == type.FullName)
					{
						flag = true;
					}
				}
				else if (ReflectionExtensions.ReferenceEqual(inspector.Target, target))
				{
					flag = true;
				}
				if (flag)
				{
					UIManager.SetPanelActive(UIManager.Panels.Inspector, active: true);
					SetInspectorActive(inspector);
					return true;
				}
			}
			return false;
		}

		public static void SetInspectorActive(InspectorBase inspector)
		{
			UnsetActiveInspector();
			ActiveInspector = inspector;
			inspector.OnSetActive();
		}

		public static void UnsetActiveInspector()
		{
			if (ActiveInspector != null)
			{
				lastActiveInspector = ActiveInspector;
				ActiveInspector.OnSetInactive();
				ActiveInspector = null;
			}
		}

		public static void CloseAllTabs()
		{
			if (Inspectors.Any())
			{
				for (int num = Inspectors.Count - 1; num >= 0; num--)
				{
					Inspectors[num].CloseInspector();
				}
				Inspectors.Clear();
			}
			UIManager.SetPanelActive(UIManager.Panels.Inspector, active: false);
		}

		public static void InspectWithFilters(object target, string filterInputField, UnityExplorer.Inspectors.MemberFilter memberFilterFlags = UnityExplorer.Inspectors.MemberFilter.All, bool staticReflection = false, CacheObjectBase parent = null)
		{
			if (!TryFocusActiveInspector(target))
			{
				ReflectionInspector reflectionInspector = CreateInspector<ReflectionInspector>(target, staticReflection, parent);
				reflectionInspector.filterInputField.Text = filterInputField;
				reflectionInspector.memberFilter = memberFilterFlags;
				reflectionInspector.Update();
			}
		}

		private static T CreateInspector<T>(object target, bool staticReflection = false, CacheObjectBase parent = null) where T : InspectorBase
		{
			T val = Pool<T>.Borrow();
			Inspectors.Add(val);
			val.Target = target;
			if (parent != null && parent.CanWrite && target.GetType().IsValueType && val is ReflectionInspector reflectionInspector)
			{
				reflectionInspector.ParentCacheObject = parent;
			}
			UIManager.SetPanelActive(UIManager.Panels.Inspector, active: true);
			val.UIRoot.transform.SetParent(InspectorPanel.Instance.ContentHolder.transform, false);
			if (val is ReflectionInspector reflectionInspector2)
			{
				reflectionInspector2.StaticOnly = staticReflection;
			}
			val.OnBorrowedFromPool(target);
			SetInspectorActive(val);
			InspectorManager.OnInspectedTabsChanged?.Invoke();
			return val;
		}

		public static void ReleaseInspector<T>(T inspector) where T : InspectorBase
		{
			if (lastActiveInspector == inspector)
			{
				lastActiveInspector = null;
			}
			bool flag = ActiveInspector == inspector;
			int num = Inspectors.IndexOf(inspector);
			Inspectors.Remove(inspector);
			inspector.OnReturnToPool();
			Pool<T>.Return(inspector);
			if (flag)
			{
				ActiveInspector = null;
				if (lastActiveInspector != null)
				{
					SetInspectorActive(lastActiveInspector);
					lastActiveInspector = null;
				}
				else if (Inspectors.Any())
				{
					int index = Math.Min(Inspectors.Count - 1, Math.Max(0, num - 1));
					SetInspectorActive(Inspectors[index]);
				}
				else
				{
					UIManager.SetPanelActive(UIManager.Panels.Inspector, active: false);
				}
			}
			InspectorManager.OnInspectedTabsChanged?.Invoke();
		}

		internal static void Update()
		{
			for (int num = Inspectors.Count - 1; num >= 0; num--)
			{
				Inspectors[num].Update();
			}
		}

		internal static void OnPanelResized(float width)
		{
			PanelWidth = width;
			foreach (InspectorBase inspector in Inspectors)
			{
				if (inspector is ReflectionInspector reflectionInspector)
				{
					reflectionInspector.SetLayouts();
				}
			}
		}
	}
	[BepInPlugin("com.originalnicodr.cinematicunityexplorer", "UnityExplorer", "1.4.0")]
	public class ExplorerBepInPlugin : BasePlugin, IExplorerLoader
	{
		public static ExplorerBepInPlugin Instance;

		private const string IL2CPP_LIBS_FOLDER = "interop";

		private BepInExConfigHandler _configHandler;

		private static readonly Harmony s_harmony = new Harmony("com.originalnicodr.cinematicunityexplorer");

		public ManualLogSource LogSource => ((BasePlugin)this).Log;

		public string UnhollowedModulesFolder => Path.Combine(Paths.BepInExRootPath, "interop");

		public ConfigHandler ConfigHandler => _configHandler;

		public Harmony HarmonyInstance => s_harmony;

		public string ExplorerFolderName => "CinematicUnityExplorer";

		public string ExplorerFolderDestination => Paths.PluginPath;

		public Action<object> OnLogMessage => LogSource.LogMessage;

		public Action<object> OnLogWarning => LogSource.LogWarning;

		public Action<object> OnLogError => LogSource.LogError;

		private void Init()
		{
			Instance = this;
			_configHandler = new BepInExConfigHandler();
			ExplorerCore.Init(this);
		}

		public override void Load()
		{
			Init();
		}
	}
	public interface IExplorerLoader
	{
		string ExplorerFolderDestination { get; }

		string ExplorerFolderName { get; }

		string UnhollowedModulesFolder { get; }

		ConfigHandler ConfigHandler { get; }

		Action<object> OnLogMessage { get; }

		Action<object> OnLogWarning { get; }

		Action<object> OnLogError { get; }
	}
}
namespace UnityExplorer.CatmullRom
{
	[Serializable]
	public struct CatmullRomPoint
	{
		public Vector3 position;

		public Quaternion rotation;

		public float fov;

		public CatmullRomPoint(Vector3 position, Quaternion rotation, float fov)
		{
			//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_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			this.position = position;
			this.rotation = rotation;
			this.fov = fov;
		}

		public CatmullRomPoint(Vector3 position, Vector4 rotation, float fov)
		{
			//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_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			this.position = position;
			this.rotation = Vector4ToQuaternion(rotation);
			this.fov = fov;
		}

		public static Vector4 QuaternionToVector4(Quaternion q)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			return new Vector4(q.x, q.y, q.z, q.w);
		}

		public static Quaternion Vector4ToQuaternion(Vector4 v)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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 CatmullRomPoint operator +(CatmullRomPoint a, CatmullRomPoint b)
		{
			//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_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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_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)
			//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_0033: Unknown result type (might be due to invalid IL or missing references)
			Vector4 val = QuaternionToVector4(a.rotation);
			Vector4 val2 = QuaternionToVector4(b.rotation);
			Vector4 v = val + val2;
			return new CatmullRomPoint(a.position + b.position, Vector4ToQuaternion(v), a.fov + b.fov);
		}

		public static CatmullRomPoint operator -(CatmullRomPoint a, CatmullRomPoint b)
		{
			//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_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)
			//IL_001c: 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_0024: 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)
			Vector4 v = QuaternionToVector4(a.rotation) - QuaternionToVector4(b.rotation);
			return new CatmullRomPoint(a.position - b.position, Vector4ToQuaternion(v), a.fov - b.fov);
		}

		public static CatmullRomPoint operator /(CatmullRomPoint a, float b)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			return new CatmullRomPoint(a.position / b, a.rotation, a.fov);
		}

		public static CatmullRomPoint operator *(CatmullRomPoint a, float b)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			return new CatmullRomPoint(a.position * b, a.rotation, a.fov);
		}

		public CatmullRomPoint Normalize()
		{
			((Vector3)(ref position)).Normalize();
			return this;
		}
	}
	public class CatmullRomMover : MonoBehaviour
	{
		public bool playingPath;

		private bool closedLoop;

		private CatmullRomPoint[] splinePoints;

		private List<CatmullRomPoint> lookaheadPoints = new List<CatmullRomPoint>();

		private CatmullRomPoint lookahead;

		private float lookaheadDelta;

		private float time;

		private float speed;

		private float delta;

		private float tension = 0f;

		private float alpha = 0.5f;

		private CatmullRomPoint pauseCamCache;

		static CatmullRomMover()
		{
			ClassInjector.RegisterTypeInIl2Cpp<CatmullRomMover>();
		}

		public CatmullRomMover(IntPtr ptr)
			: base(ptr)
		{
		}

		public CatmullRomMover()
		{
			splinePoints = new CatmullRomPoint[0];
			lookaheadPoints = new List<CatmullRomPoint>();
		}

		public void StartPath()
		{
			if (splinePoints == null || splinePoints.Length <= 2)
			{
				CatmullRomPoint[] array = splinePoints;
				int value = ((array != null) ? array.Length : 0);
				ExplorerCore.LogWarning($"Cannot start camera path: Need at least 3 nodes, but only {value} node(s) exist. Please add more nodes to create a path.");
				throw new ArgumentException("Catmull Rom Error: Too few spline points!");
			}
			playingPath = true;
			delta = lookaheadDelta;
			MoveCameraToPoint(splinePoints[0]);
			lookahead = lookaheadPoints[1];
		}

		public void TogglePause()
		{
			playingPath = !playingPath;
			if (!playingPath)
			{
				pauseCamCache = GetCurrentPoint();
			}
			else
			{
				MoveCameraToPoint(pauseCamCache);
			}
		}

		public bool IsPaused()
		{
			return playingPath;
		}

		public void Stop()
		{
			playingPath = false;
			delta = lookaheadDelta;
			lookahead = GetPointFromPath(delta);
			MoveCameraToPoint(splinePoints[0]);
			pauseCamCache = GetCurrentPoint();
		}

		public void setClosedLoop(bool newClosedLoop)
		{
			closedLoop = newClosedLoop;
		}

		[HideFromIl2Cpp]
		public void setSplinePoints(CatmullRomPoint[] newSplinePoints)
		{
			splinePoints = newSplinePoints;
		}

		public void setTime(float newTime)
		{
			time = newTime;
		}

		public void setCatmullRomVariables(float newAlpha, float newTension)
		{
			alpha = newAlpha;
			tension = newTension;
		}

		private void Update()
		{
			if (playingPath)
			{
				AdvanceMover(Time.fixedDeltaTime);
			}
		}

		private CatmullRomPoint GetCurrentPoint()
		{
			//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_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_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)
			Vector3 cameraPosition = FreeCamPanel.GetCameraPosition();
			Quaternion cameraRotation = FreeCamPanel.GetCameraRotation();
			return new CatmullRomPoint(cameraPosition, cameraRotation, FreeCamPanel.GetFreecam().fieldOfView);
		}

		private void AdvanceMover(float dt)
		{
			//IL_0021: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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)
			float num = 1f / 60f * speed;
			while ((double)num > 0.0)
			{
				CatmullRomPoint currentPoint = GetCurrentPoint();
				float num2 = Vector3.Distance(lookahead.position, currentPoint.position);
				float num3 = Math.Min(num, num2);
				MoveCameraStep(currentPoint, num3, num2);
				num -= num3;
				currentPoint = GetCurrentPoint();
				for (num2 = Vector3.Distance(lookahead.position, currentPoint.position); num2 <= 0.0002f; num2 = Vector3.Distance(lookahead.position, currentPoint.position))
				{
					if (delta >= 1f)
					{
						PathFinished();
					}
					delta = Math.Min(delta + lookaheadDelta, 1f);
					int index = (int)((float)(lookaheadPoints.Count - 1) * delta);
					lookahead = lookaheadPoints[index];
				}
			}
		}

		public void MoveCameraStep(CatmullRomPoint currentPoint, float actual, float room)
		{
			//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_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 m