using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Generics.Dynamics;
using HG;
using IDRSJsonLoader;
using IDRSJsonLoader.Models;
using ItemDisplayPlacementHelper.AnimatorEditing;
using ItemDisplayPlacementHelper.Assets.ItemDisplayPlacementHelper;
using ItemDisplayPlacementHelper.AxisEditing;
using ItemDisplayPlacementHelper.Dialogs;
using ItemDisplayPlacementHelper.Editable;
using ItemDisplayPlacementHelper.Native;
using ItemDisplayPlacementHelper.Native.Structs;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using RoR2;
using RoR2.AddressableAssets;
using RoR2.ContentManagement;
using RoR2.UI;
using TMPro;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.AddressableAssets.ResourceLocators;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.ResourceLocations;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsUnmanagedAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NativeIntegerAttribute : Attribute
	{
		public readonly bool[] TransformFlags;

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

		public NativeIntegerAttribute(bool[] P_0)
		{
			TransformFlags = P_0;
		}
	}
}
public class InvariatCultureDecimalValidator : MonoBehaviour
{
	private void Awake()
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Expected O, but got Unknown
		((Component)this).GetComponent<TMP_InputField>().onValidateInput = new OnValidateInput(Validate);
	}

	private char Validate(string text, int pos, char ch)
	{
		if ((pos != 0 || text.Length <= 0 || text[0] != '-') && ((ch >= '0' && ch <= '9') || (ch == '-' && pos == 0) || (ch == '.' && !text.Contains("."))))
		{
			return ch;
		}
		return '\0';
	}
}
namespace ItemDisplayPlacementHelper
{
	public class AnimatorParametersController : MonoBehaviour
	{
		private CharacterModel currentModel;

		private Animator currentAnimator;

		public Transform container;

		private readonly List<AnimatorParameterField> rows = new List<AnimatorParameterField>();

		[Space]
		public Button toggleButton;

		public GameObject itemPanel;

		public GameObject parametersPanel;

		[Space]
		public GameObject boolRowPrefab;

		public GameObject intRowPrefab;

		public GameObject floatRowPrefab;

		private void Awake()
		{
			ModelPicker.OnModelChanged += OnModelChanged;
			ModelPicker.OnModelWillChange += OnModelWillChange;
		}

		private void OnDestroy()
		{
			ModelPicker.OnModelChanged -= OnModelChanged;
			ModelPicker.OnModelWillChange -= OnModelWillChange;
		}

		private void OnModelWillChange()
		{
			foreach (AnimatorParameterField row in rows)
			{
				Object.Destroy((Object)(object)((Component)row).gameObject);
			}
			rows.Clear();
			currentAnimator = null;
		}

		private void OnModelChanged(CharacterModel model)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected I4, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Invalid comparison between Unknown and I4
			currentModel = model;
			if (Object.op_Implicit((Object)(object)currentModel))
			{
				currentAnimator = ((Component)currentModel).GetComponent<Animator>();
			}
			if (!Object.op_Implicit((Object)(object)currentAnimator))
			{
				return;
			}
			AnimatorControllerParameter[] parameters = currentAnimator.parameters;
			foreach (AnimatorControllerParameter val in parameters)
			{
				GameObject val2 = null;
				AnimatorControllerParameterType type = val.type;
				switch (type - 1)
				{
				default:
					if ((int)type == 9)
					{
						continue;
					}
					break;
				case 0:
					val2 = Object.Instantiate<GameObject>(floatRowPrefab, container);
					break;
				case 2:
					val2 = Object.Instantiate<GameObject>(intRowPrefab, container);
					break;
				case 3:
					val2 = Object.Instantiate<GameObject>(boolRowPrefab, container);
					break;
				case 1:
					break;
				}
				AnimatorParameterField component = val2.GetComponent<AnimatorParameterField>();
				component.animator = currentAnimator;
				component.parameter = val;
				rows.Add(component);
				val2.SetActive(true);
			}
		}

		public void Toggle()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if (parametersPanel.activeSelf)
			{
				parametersPanel.SetActive(false);
				itemPanel.SetActive(true);
			}
			else
			{
				parametersPanel.SetActive(true);
				itemPanel.SetActive(false);
			}
			Vector3 localScale = ((Component)toggleButton).transform.localScale;
			localScale.y *= -1f;
			((Component)toggleButton).transform.localScale = localScale;
		}
	}
	internal static class AssetsHelper
	{
		public static AssetBundle SceneBundle { get; private set; }

		public static void LoadAssetBundle()
		{
			SceneBundle = AssetBundle.LoadFromFile(GetBundlePath("kingenderbrine_idrs_editor"));
		}

		private static string GetBundlePath(string bundleName)
		{
			return Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)ItemDisplayPlacementHelperPlugin.Instance).Info.Location), bundleName);
		}
	}
	public class BepInExConfigController : MonoBehaviour
	{
		public SensitivityController sensitivityController;

		public ParentedPrefabDisplayController parentedPrefabDisplayController;

		private void Start()
		{
			sensitivityController.fastCoefficientInput.Value = ConfigHelper.FastCoefficient.Value;
			sensitivityController.slowCoefficientInput.Value = ConfigHelper.SlowCoefficient.Value;
			parentedPrefabDisplayController.CopyFormat = ConfigHelper.CopyFormat.Value;
			parentedPrefabDisplayController.customFormatInput.text = FromConfigFriendly(ConfigHelper.CustomFormat.Value);
			((MonoBehaviour)this).StartCoroutine(SaveCurrentValues());
		}

		private void OnDestroy()
		{
			((MonoBehaviour)this).StopAllCoroutines();
		}

		private IEnumerator SaveCurrentValues()
		{
			while (true)
			{
				yield return (object)new WaitForSeconds(10f);
				ConfigHelper.FastCoefficient.Value = sensitivityController.fastCoefficientInput.Value;
				ConfigHelper.SlowCoefficient.Value = sensitivityController.slowCoefficientInput.Value;
				ConfigHelper.CopyFormat.Value = parentedPrefabDisplayController.CopyFormat;
				ConfigHelper.CustomFormat.Value = ToConfigFriendly(parentedPrefabDisplayController.customFormatInput.text);
			}
		}

		private static string ToConfigFriendly(string str)
		{
			return Convert.ToBase64String(Encoding.UTF8.GetBytes(str)).Replace('=', '-');
		}

		private static string FromConfigFriendly(string str)
		{
			return Encoding.UTF8.GetString(Convert.FromBase64String(str.Replace('-', '=')));
		}
	}
	public class CameraPostprocessEventHandler : MonoBehaviour
	{
		public static EventHandler onPostRender;

		private void OnPostRender()
		{
			onPostRender?.Invoke(this, null);
		}
	}
	public static class ConfigHelper
	{
		public static ConfigFile ConfigFile { get; private set; }

		public static ConfigEntry<float> FastCoefficient { get; private set; }

		public static ConfigEntry<float> SlowCoefficient { get; private set; }

		public static ConfigEntry<CopyFormat> CopyFormat { get; private set; }

		public static ConfigEntry<string> CustomFormat { get; private set; }

		public static ConfigEntry<string> FilePickerLastPath { get; private set; }

		public static ConfigEntry<string> ExportNamespace { get; private set; }

		public static ConfigEntry<bool> ExportGenerateClass { get; private set; }

		public static ConfigEntry<AssetsToExport> ExportAssetsToExport { get; private set; }

		public static ConfigEntry<ImportType> ImportImportType { get; private set; }

		public static ConfigEntry<bool> ExportWithSkin { get; private set; }

		internal static void InitConfigs(ConfigFile config)
		{
			ConfigFile = config;
			config.SaveOnConfigSet = false;
			FastCoefficient = config.Bind<float>("EditorInputs", "FastCoefficient", 2.5f, (ConfigDescription)null);
			SlowCoefficient = config.Bind<float>("EditorInputs", "SlowCoefficient", 0.1f, (ConfigDescription)null);
			CopyFormat = config.Bind<CopyFormat>("EditorInputs", "CopyFormat", ItemDisplayPlacementHelper.CopyFormat.Block, (ConfigDescription)null);
			CustomFormat = config.Bind<string>("EditorInputs", "CustomFormat", "", (ConfigDescription)null);
			FilePickerLastPath = config.Bind<string>("Cache", "FilePickerLastPath", "", (ConfigDescription)null);
			ExportGenerateClass = config.Bind<bool>("Cache", "ExportGenerateClass", false, (ConfigDescription)null);
			ExportNamespace = config.Bind<string>("Cache", "ExportNamespace", "", (ConfigDescription)null);
			ExportAssetsToExport = config.Bind<AssetsToExport>("Cache", "ExportAssetsToExport", AssetsToExport.All, (ConfigDescription)null);
			ExportWithSkin = config.Bind<bool>("Cache", "ExportWithSkin", false, (ConfigDescription)null);
			ImportImportType = config.Bind<ImportType>("Cache", "ImportImportType", ImportType.ReplaceSet, (ConfigDescription)null);
			config.SaveOnConfigSet = true;
			config.Save();
		}
	}
	public class DisplayRuleGroupEditingController : MonoBehaviour
	{
		public delegate void OnDisplayRuleGroupChangedHandler(EditableDisplayRuleGroup keyAssetRuleGroup);

		public GameObject rowPrefab;

		public Transform container;

		public Button reapplyButton;

		public Button addButton;

		public Button deleteButton;

		private CharacterModel characterModel;

		public static OnDisplayRuleGroupChangedHandler OnDisplayRuleGroupChanged;

		private readonly List<ItemDisplayRulePreviewController> rows = new List<ItemDisplayRulePreviewController>();

		public static DisplayRuleGroupEditingController Instance { get; private set; }

		public EditableDisplayRuleGroup DisplayRuleGroup { get; private set; }

		private void Awake()
		{
			Instance = this;
			ModelPicker.OnModelWillChange += OnModelWillChange;
			ModelPicker.OnModelChanged += OnModelChanged;
		}

		private void OnDestroy()
		{
			ModelPicker.OnModelWillChange -= OnModelWillChange;
			ModelPicker.OnModelChanged -= OnModelChanged;
			Instance = null;
		}

		private void Update()
		{
			bool flag = DisplayRuleGroup != null;
			((Selectable)reapplyButton).interactable = flag;
			((Selectable)addButton).interactable = flag;
			((Selectable)deleteButton).interactable = flag && ParentedPrefabDisplayController.Instance.ItemDisplayRule != null;
		}

		private void OnModelWillChange()
		{
			SetDisplayRuleGroup(null);
		}

		private void OnModelChanged(CharacterModel characterModel)
		{
			this.characterModel = characterModel;
		}

		public void SetDisplayRuleGroup(EditableDisplayRuleGroup displayRuleGroup)
		{
			if (DisplayRuleGroup == displayRuleGroup)
			{
				return;
			}
			DisplayRuleGroup = displayRuleGroup;
			foreach (ItemDisplayRulePreviewController row in rows)
			{
				Object.Destroy((Object)(object)((Component)row).gameObject);
			}
			rows.Clear();
			if (displayRuleGroup == null || !Object.op_Implicit((Object)(object)characterModel))
			{
				OnDisplayRuleGroupChanged(displayRuleGroup);
				return;
			}
			List<EditableItemDisplayRule> rules = displayRuleGroup.Rules;
			for (int i = 0; i < rules.Count; i++)
			{
				EditableItemDisplayRule rule = rules[i];
				CreateRow(rule);
			}
			OnDisplayRuleGroupChanged(displayRuleGroup);
		}

		private void CreateRow(EditableItemDisplayRule rule)
		{
			GameObject obj = Object.Instantiate<GameObject>(rowPrefab, container);
			ItemDisplayRulePreviewController component = obj.GetComponent<ItemDisplayRulePreviewController>();
			component.itemDisplayRule = rule;
			obj.SetActive(true);
			rows.Add(component);
		}

		public void ReapplyCurrentDisplayGroup()
		{
			DisplayRuleGroup.Disable(characterModel);
			DisplayRuleGroup.Enable(characterModel);
		}

		public void Add()
		{
			//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)
			EditableItemDisplayRule editableItemDisplayRule = new EditableItemDisplayRule();
			editableItemDisplayRule.localScale = Vector3.one;
			DisplayRuleGroup.Rules.Add(editableItemDisplayRule);
			CreateRow(editableItemDisplayRule);
			editableItemDisplayRule.Enable(characterModel);
		}

		public void Delete()
		{
			EditableItemDisplayRule itemDisplayRule = ParentedPrefabDisplayController.Instance.ItemDisplayRule;
			ParentedPrefabDisplayController.Instance.SetItemDisplayRule(null);
			for (int i = 0; i < rows.Count; i++)
			{
				ItemDisplayRulePreviewController itemDisplayRulePreviewController = rows[i];
				if (itemDisplayRulePreviewController.itemDisplayRule == itemDisplayRule)
				{
					itemDisplayRule.Disable(characterModel);
					rows.RemoveAt(i);
					DisplayRuleGroup.Rules.RemoveAt(i);
					Object.Destroy((Object)(object)((Component)itemDisplayRulePreviewController).gameObject);
					break;
				}
			}
		}
	}
	public class DisplayRuleGroupPreviewController : MonoBehaviour
	{
		[NonSerialized]
		[HideInInspector]
		public Sprite icon;

		[NonSerialized]
		[HideInInspector]
		public string nameText;

		[NonSerialized]
		[HideInInspector]
		public EditableDisplayRuleGroup displayRuleGroup;

		private CharacterModel characterModel;

		[SerializeField]
		private Image imageComponent;

		[SerializeField]
		private TextMeshProUGUI textComponent;

		[SerializeField]
		private Toggle toggleComponent;

		[SerializeField]
		private Button buttonComponent;

		[SerializeField]
		private ToggleGroup toggleGroupComponent;

		[SerializeField]
		private Image background;

		private void Awake()
		{
			characterModel = ModelPicker.Instance.CharacterModel;
			ModelPicker.OnModelChanged += OnModelChanged;
		}

		private void OnDestroy()
		{
			ModelPicker.OnModelChanged -= OnModelChanged;
		}

		private void OnModelChanged(CharacterModel characterModel)
		{
			this.characterModel = characterModel;
		}

		private void Start()
		{
			((TMP_Text)textComponent).text = nameText;
			imageComponent.sprite = icon;
			toggleComponent.isOn = displayRuleGroup.Enabled;
		}

		public void EditDisplayRuleGroup()
		{
			if (DisplayRuleGroupEditingController.Instance.DisplayRuleGroup == displayRuleGroup)
			{
				DisplayRuleGroupEditingController.Instance.SetDisplayRuleGroup(null);
				return;
			}
			toggleComponent.isOn = true;
			DisplayRuleGroupEditingController.Instance.SetDisplayRuleGroup(displayRuleGroup);
		}

		public void ToggleDisplay(bool display)
		{
			if (toggleComponent.isOn != display)
			{
				toggleComponent.isOn = display;
				return;
			}
			if (display)
			{
				displayRuleGroup.Enable(characterModel);
				return;
			}
			displayRuleGroup.Disable(characterModel);
			if (DisplayRuleGroupEditingController.Instance.DisplayRuleGroup == displayRuleGroup)
			{
				DisplayRuleGroupEditingController.Instance.SetDisplayRuleGroup(null);
			}
		}

		private void Update()
		{
			((Behaviour)background).enabled = DisplayRuleGroupEditingController.Instance.DisplayRuleGroup == displayRuleGroup;
		}
	}
	public class DropdownItem : MonoBehaviour, IEventSystemHandler, ICancelHandler
	{
		public TMP_Text text;

		public Image image;

		public RectTransform rectTransform;

		public Button button;

		[HideInInspector]
		public object Value { get; set; }

		public virtual void OnCancel(BaseEventData eventData)
		{
			SearchableDropdown componentInParent = ((Component)this).GetComponentInParent<SearchableDropdown>();
			if (Object.op_Implicit((Object)(object)componentInParent))
			{
				componentInParent.Hide();
			}
		}
	}
	public class EditorConfigPanel : MonoBehaviour
	{
		private static readonly MethodInfo dynamicBonesLateUpdateMethod = typeof(DynamicBone).GetMethod("LateUpdate", BindingFlags.Instance | BindingFlags.NonPublic);

		private static readonly MethodInfo timeGetUnscaledDeltaTimeMethod = typeof(Time).GetProperty("unscaledDeltaTime").GetGetMethod();

		public CameraRigController cameraRigController;

		[Space]
		public Toggle fadeToggle;

		public Toggle timeToggle;

		public Toggle dynamicBonesTimeToggle;

		[Space]
		public Button editorSpaceButton;

		public TextMeshProUGUI editorSpaceText;

		[Space]
		public Toggle editorModeMove;

		public Toggle editorModeRotate;

		public Toggle editorModeScale;

		private bool skipNotification;

		private ILHook dynamicBonesHook;

		private void OnDestroy()
		{
			if (dynamicBonesHook != null)
			{
				dynamicBonesHook.Undo();
			}
		}

		private void Update()
		{
			skipNotification = true;
			if (Object.op_Implicit((Object)(object)cameraRigController))
			{
				fadeToggle.isOn = cameraRigController.enableFading;
			}
			timeToggle.isOn = Time.timeScale > 0f;
			((Selectable)editorSpaceButton).interactable = !EditorAxisController.Instance.OverrideToLocalSpace;
			switch (EditorAxisController.Instance.EditSpace)
			{
			case EditSpace.Global:
				((TMP_Text)editorSpaceText).text = "Global";
				break;
			case EditSpace.Local:
				((TMP_Text)editorSpaceText).text = "Local";
				break;
			}
			editorModeMove.isOn = EditorAxisController.Instance.EditMode == EditMode.Move;
			editorModeRotate.isOn = EditorAxisController.Instance.EditMode == EditMode.Rotate;
			editorModeScale.isOn = EditorAxisController.Instance.EditMode == EditMode.Scale;
			skipNotification = false;
		}

		public void ToggleTime(bool enabled)
		{
			if (!skipNotification)
			{
				Time.timeScale = (enabled ? 1 : 0);
			}
		}

		public void ToggleFade(bool enabled)
		{
			if (!skipNotification && Object.op_Implicit((Object)(object)cameraRigController))
			{
				cameraRigController.enableFading = enabled;
			}
		}

		public void ToggleEditModeMove(bool value)
		{
			if (!skipNotification && value)
			{
				EditorAxisController.Instance.EditMode = EditMode.Move;
			}
		}

		public void ToggleEditModeScale(bool value)
		{
			if (!skipNotification && value)
			{
				EditorAxisController.Instance.EditMode = EditMode.Scale;
			}
		}

		public void ToggleEditModeRotate(bool value)
		{
			if (!skipNotification && value)
			{
				EditorAxisController.Instance.EditMode = EditMode.Rotate;
			}
		}

		public void ToggleEditSpace()
		{
			switch (EditorAxisController.Instance.ActualEditSpace)
			{
			case EditSpace.Global:
				EditorAxisController.Instance.ActualEditSpace = EditSpace.Local;
				break;
			case EditSpace.Local:
				EditorAxisController.Instance.ActualEditSpace = EditSpace.Global;
				break;
			}
		}

		public void ToggleDynamicBonesTimeScale(bool enabled)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			if (skipNotification)
			{
				return;
			}
			if (enabled)
			{
				if (dynamicBonesHook == null)
				{
					dynamicBonesHook = new ILHook((MethodBase)dynamicBonesLateUpdateMethod, new Manipulator(DynamicBonesLateUpdateIL));
				}
			}
			else if (dynamicBonesHook != null)
			{
				dynamicBonesHook.Undo();
				dynamicBonesHook = null;
			}
		}

		private void DynamicBonesLateUpdateIL(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Time>(x, "get_deltaTime")
			});
			val.Emit(OpCodes.Pop);
			val.Emit(OpCodes.Call, (MethodBase)timeGetUnscaledDeltaTimeMethod);
		}
	}
	public class EditorHUD : MonoBehaviour
	{
		public EditorSceneCameraController cameraController;

		public CameraRigController cameraRigController;

		private float oldTimeScale;

		public static EditorHUD Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
			oldTimeScale = Time.timeScale;
			Time.timeScale = 1f;
			AkSoundEngine.PostEvent("Pause_All", (GameObject)null);
			PauseManager.onPauseEndGlobal = (Action)Delegate.Combine(PauseManager.onPauseEndGlobal, new Action(OnPauseEnd));
		}

		private void Start()
		{
			((Behaviour)((Component)this).GetComponent<CursorOpener>()).enabled = true;
		}

		private void OnDestroy()
		{
			Instance = null;
			PauseManager.onPauseEndGlobal = (Action)Delegate.Remove(PauseManager.onPauseEndGlobal, new Action(OnPauseEnd));
			Time.timeScale = oldTimeScale;
			AkSoundEngine.PostEvent("Unpause_All", (GameObject)null);
		}

		private void Update()
		{
			if ((double)Time.timeScale < 0.01)
			{
				Physics.SyncTransforms();
			}
		}

		private void OnPauseEnd()
		{
			AkSoundEngine.PostEvent("Pause_All", (GameObject)null);
		}
	}
	public class EditorKeysHandler : MonoBehaviour
	{
		public CameraRigController cameraRigController;

		private MPEventSystemLocator eventSystemLocator;

		private GameObject lastCheckedObject;

		private bool disallowKeyPress;

		private void Awake()
		{
			eventSystemLocator = ((Component)this).GetComponent<MPEventSystemLocator>();
		}

		private void Update()
		{
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)eventSystemLocator.eventSystem))
			{
				return;
			}
			GameObject currentSelectedGameObject = ((EventSystem)eventSystemLocator.eventSystem).currentSelectedGameObject;
			if (!Object.op_Implicit((Object)(object)currentSelectedGameObject))
			{
				disallowKeyPress = false;
				lastCheckedObject = null;
			}
			else if ((Object)(object)currentSelectedGameObject != (Object)(object)lastCheckedObject)
			{
				if (Object.op_Implicit((Object)(object)currentSelectedGameObject.GetComponent<TMP_InputField>()) || Object.op_Implicit((Object)(object)currentSelectedGameObject.GetComponent<InputField>()))
				{
					disallowKeyPress = true;
				}
				else
				{
					disallowKeyPress = false;
				}
				lastCheckedObject = currentSelectedGameObject;
			}
			if (disallowKeyPress)
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)119))
			{
				EditorAxisController.Instance.EditMode = EditMode.Move;
			}
			else if (Input.GetKeyDown((KeyCode)101))
			{
				EditorAxisController.Instance.EditMode = EditMode.Rotate;
			}
			else if (Input.GetKeyDown((KeyCode)114))
			{
				EditorAxisController.Instance.EditMode = EditMode.Scale;
			}
			if (Input.GetKeyDown((KeyCode)120))
			{
				switch (EditorAxisController.Instance.ActualEditSpace)
				{
				case EditSpace.Global:
					EditorAxisController.Instance.ActualEditSpace = EditSpace.Local;
					break;
				case EditSpace.Local:
					EditorAxisController.Instance.ActualEditSpace = EditSpace.Global;
					break;
				}
			}
			if (Input.GetKeyDown((KeyCode)116))
			{
				Time.timeScale = ((Time.timeScale == 0f) ? 1 : 0);
			}
			if (Input.GetKeyDown((KeyCode)102) && Object.op_Implicit((Object)(object)ParentedPrefabDisplayController.Instance) && Object.op_Implicit((Object)(object)ParentedPrefabDisplayController.Instance.ItemDisplayRule?.instance))
			{
				EditorSceneCameraController.Instance.FocusOnPoint(ParentedPrefabDisplayController.Instance.ItemDisplayRule.instance.transform.position);
			}
			if (Input.GetKeyDown((KeyCode)103) && Object.op_Implicit((Object)(object)cameraRigController))
			{
				cameraRigController.enableFading = !cameraRigController.enableFading;
			}
		}
	}
	public class EditorSceneCameraController : MonoBehaviour, ICameraStateProvider, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
	{
		private enum ActionType
		{
			None,
			Rotation,
			Movement
		}

		private const float minFocusLength = 0.1f;

		private float focusLength = 4f;

		private const float rotationMultiplier = 0.15f;

		private const float sidewaysMovementMultiplier = 0.01f;

		private const float forwardMovementMultiplier = 0.3f;

		public float sidewaysMovementSensitivity = 1f;

		public float rotationSensitivity = 1f;

		public float forwardMovementSensitivity = 1f;

		public float slowCoefficient = 0.1f;

		public float fastCoefficient = 3f;

		[Space]
		public Transform cameraDefaultPosition;

		public CameraRigController CameraRigController;

		public static EditorSceneCameraController Instance;

		private Vector3 previousMousePosition;

		private ActionType currentActionType;

		private Vector3? lerpPosition;

		private float lerpCameraTime;

		public bool PointerInside { get; private set; }

		private void Awake()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			CameraRigController.SetOverrideCam((ICameraStateProvider)(object)this, 0f);
			((Component)CameraRigController).transform.SetPositionAndRotation(cameraDefaultPosition.position, cameraDefaultPosition.rotation);
		}

		private void OnDestroy()
		{
			Instance = null;
			if (Object.op_Implicit((Object)(object)CameraRigController))
			{
				CameraRigController.SetOverrideCam((ICameraStateProvider)null, 0f);
			}
		}

		private void Update()
		{
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0379: Unknown result type (might be due to invalid IL or missing references)
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0544: Unknown result type (might be due to invalid IL or missing references)
			//IL_0549: Unknown result type (might be due to invalid IL or missing references)
			//IL_0574: Unknown result type (might be due to invalid IL or missing references)
			//IL_0579: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04be: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0511: Unknown result type (might be due to invalid IL or missing references)
			//IL_0513: Unknown result type (might be due to invalid IL or missing references)
			//IL_0518: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			//IL_0408: Unknown result type (might be due to invalid IL or missing references)
			//IL_0413: Unknown result type (might be due to invalid IL or missing references)
			//IL_041d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Unknown result type (might be due to invalid IL or missing references)
			//IL_043e: Unknown result type (might be due to invalid IL or missing references)
			//IL_044e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0453: Unknown result type (might be due to invalid IL or missing references)
			//IL_045a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0465: Unknown result type (might be due to invalid IL or missing references)
			//IL_046f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0475: Unknown result type (might be due to invalid IL or missing references)
			//IL_047a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: 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_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: 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_00d6: 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_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			float num = (Input.GetKey((KeyCode)306) ? slowCoefficient : (Input.GetKey((KeyCode)304) ? fastCoefficient : 1f));
			if (PointerInside)
			{
				if (currentActionType == ActionType.None)
				{
					if (Input.GetMouseButtonDown(2))
					{
						if (Input.GetKey((KeyCode)308))
						{
							Vector3 val = default(Vector3);
							foreach (KeyValuePair<SkinnedMeshRenderer, MeshCollider> cachedSkinnedMeshRenderer in ModelPicker.Instance.CachedSkinnedMeshRenderers)
							{
								Vector3 localScale = ((Component)cachedSkinnedMeshRenderer.Key).transform.localScale;
								Vector3 lossyScale = ((Component)cachedSkinnedMeshRenderer.Key).transform.lossyScale;
								((Vector3)(ref val))..ctor(localScale.x / lossyScale.x, localScale.y / lossyScale.y, localScale.z / lossyScale.z);
								if (localScale != Vector3.one || val != Vector3.one)
								{
									((Component)cachedSkinnedMeshRenderer.Key).transform.localScale = val;
								}
								cachedSkinnedMeshRenderer.Key.BakeMesh(cachedSkinnedMeshRenderer.Value.sharedMesh);
								cachedSkinnedMeshRenderer.Value.sharedMesh = cachedSkinnedMeshRenderer.Value.sharedMesh;
								if (localScale != Vector3.one || val != Vector3.one)
								{
									((Component)cachedSkinnedMeshRenderer.Key).transform.localScale = localScale;
								}
							}
							RaycastHit val2 = default(RaycastHit);
							if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), ref val2, 5000f, LayerMask.GetMask(new string[1] { "World" })))
							{
								lerpPosition = ((RaycastHit)(ref val2)).point + ((Component)CameraRigController).transform.forward * -1f * focusLength;
								lerpCameraTime = 0f;
							}
						}
						else
						{
							currentActionType = ActionType.Movement;
							lerpPosition = null;
						}
					}
					else if (Input.GetMouseButtonDown(1))
					{
						currentActionType = ActionType.Rotation;
						lerpPosition = null;
					}
				}
				Vector3 val3 = ((Component)CameraRigController).transform.forward * Input.mouseScrollDelta.y * forwardMovementSensitivity * 0.3f * num;
				if (Input.GetKey((KeyCode)308))
				{
					float num2 = Mathf.Sign(Input.mouseScrollDelta.y);
					if (num2 == 1f && focusLength <= 0.1f)
					{
						val3 = Vector3.zero;
						focusLength = 0.1f;
					}
					else
					{
						float num3 = Mathf.Max((float)Math.Log(focusLength), 0.5f);
						val3 *= num3;
						if (focusLength - num2 * ((Vector3)(ref val3)).magnitude <= 0.1f)
						{
							val3 = Vector3.zero;
						}
						focusLength -= num2 * ((Vector3)(ref val3)).magnitude;
					}
				}
				if (val3 != Vector3.zero)
				{
					lerpPosition = null;
				}
				Transform transform = ((Component)CameraRigController).transform;
				transform.position += val3;
			}
			if (lerpPosition.HasValue)
			{
				lerpCameraTime += Time.unscaledDeltaTime;
				((Component)CameraRigController).transform.position = Vector3.Lerp(((Component)CameraRigController).transform.position, lerpPosition.Value, lerpCameraTime);
				if (lerpCameraTime >= 1f)
				{
					lerpPosition = null;
				}
			}
			if (EditorAxisController.Instance.SelectedAxis == Axis.None)
			{
				Vector3 val4 = Input.mousePosition - previousMousePosition;
				switch (currentActionType)
				{
				case ActionType.Movement:
				{
					Transform transform2 = ((Component)CameraRigController).transform;
					transform2.position -= ((Component)CameraRigController).transform.up * val4.y * sidewaysMovementSensitivity * 0.01f * num;
					Transform transform3 = ((Component)CameraRigController).transform;
					transform3.position -= ((Component)CameraRigController).transform.right * val4.x * sidewaysMovementSensitivity * 0.01f * num;
					break;
				}
				case ActionType.Rotation:
					if (Input.GetKey((KeyCode)308))
					{
						Vector3 val5 = ((Component)CameraRigController).transform.position + ((Component)CameraRigController).transform.forward * focusLength;
						((Component)CameraRigController).transform.RotateAround(val5, ((Component)CameraRigController).transform.right, val4.y * rotationSensitivity * 0.15f * -2f);
						((Component)CameraRigController).transform.RotateAround(val5, Vector3.up, val4.x * rotationSensitivity * 0.15f * 2f);
					}
					else
					{
						((Component)CameraRigController).transform.Rotate(Vector3.right, val4.y * rotationSensitivity * 0.15f * -1f, (Space)1);
						((Component)CameraRigController).transform.Rotate(Vector3.up, val4.x * rotationSensitivity * 0.15f, (Space)0);
					}
					break;
				}
			}
			if (currentActionType != ActionType.None && Input.GetMouseButtonUp((int)currentActionType))
			{
				currentActionType = ActionType.None;
			}
			previousMousePosition = Input.mousePosition;
		}

		public void FocusOnPoint(Vector3 point)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0027: Unknown result type (might be due to invalid IL or missing references)
			lerpPosition = ((Component)CameraRigController).transform.forward * -1f * focusLength + point;
			lerpCameraTime = 0f;
		}

		public void GetCameraState(CameraRigController cameraRigController, ref CameraState cameraState)
		{
			//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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			cameraState.rotation = ((Component)cameraRigController).transform.rotation;
			cameraState.position = ((Component)cameraRigController).transform.position;
		}

		public bool IsHudAllowed(CameraRigController cameraRigController)
		{
			return false;
		}

		public bool IsUserControlAllowed(CameraRigController cameraRigController)
		{
			return false;
		}

		public bool IsUserLookAllowed(CameraRigController cameraRigController)
		{
			return false;
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			PointerInside = false;
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			PointerInside = true;
		}
	}
	public enum EditMode
	{
		Move,
		Rotate,
		Scale,
		Combined
	}
	public enum EditSpace
	{
		Global,
		Local
	}
	public enum Axis
	{
		None = 0,
		X = 1,
		Y = 2,
		Z = 4,
		CameraPerpendicular = 8,
		CameraParallel = 16,
		XY = 3,
		XZ = 5,
		YZ = 6,
		XYZ = 7
	}
	public enum CopyFormat
	{
		Custom,
		Block,
		Inline,
		ForParsing
	}
	public enum PrefabSource
	{
		Addressables,
		AssetBundle
	}
	public enum ImportType
	{
		ReplaceSet,
		AddOrUpdateGroups
	}
	public enum AssetsToExport
	{
		All,
		Filtered,
		Enabled
	}
	public class FileRowController : MonoBehaviour
	{
		public TMP_Text text;

		public Image icon;

		public Button button;

		[NonSerialized]
		public bool isFile;

		[NonSerialized]
		public string part;
	}
	internal struct FloatTween
	{
		public class FloatTweenCallback : UnityEvent<float>
		{
		}

		private FloatTweenCallback m_Target;

		private float m_StartValue;

		private float m_TargetValue;

		private float m_Duration;

		private bool m_IgnoreTimeScale;

		public float startValue
		{
			get
			{
				return m_StartValue;
			}
			set
			{
				m_StartValue = value;
			}
		}

		public float targetValue
		{
			get
			{
				return m_TargetValue;
			}
			set
			{
				m_TargetValue = value;
			}
		}

		public float duration
		{
			get
			{
				return m_Duration;
			}
			set
			{
				m_Duration = value;
			}
		}

		public bool ignoreTimeScale
		{
			get
			{
				return m_IgnoreTimeScale;
			}
			set
			{
				m_IgnoreTimeScale = value;
			}
		}

		public void TweenValue(float floatPercentage)
		{
			if (ValidTarget())
			{
				((UnityEvent<float>)m_Target).Invoke(Mathf.Lerp(m_StartValue, m_TargetValue, floatPercentage));
			}
		}

		public void AddOnChangedCallback(UnityAction<float> callback)
		{
			if (m_Target == null)
			{
				m_Target = new FloatTweenCallback();
			}
			((UnityEvent<float>)m_Target).AddListener(callback);
		}

		public bool GetIgnoreTimescale()
		{
			return m_IgnoreTimeScale;
		}

		public float GetDuration()
		{
			return m_Duration;
		}

		public bool ValidTarget()
		{
			return m_Target != null;
		}
	}
	internal class FloatTweenRunner
	{
		protected MonoBehaviour m_CoroutineContainer;

		protected IEnumerator m_Tween;

		private static IEnumerator Start(FloatTween tweenInfo)
		{
			if (tweenInfo.ValidTarget())
			{
				float elapsedTime = 0f;
				while ((double)elapsedTime < (double)tweenInfo.duration)
				{
					elapsedTime += (tweenInfo.ignoreTimeScale ? Time.unscaledDeltaTime : Time.deltaTime);
					tweenInfo.TweenValue(Mathf.Clamp01(elapsedTime / tweenInfo.duration));
					yield return null;
				}
				tweenInfo.TweenValue(1f);
			}
		}

		public void Init(MonoBehaviour coroutineContainer)
		{
			m_CoroutineContainer = coroutineContainer;
		}

		public void StartTween(FloatTween info)
		{
			if ((Object)(object)m_CoroutineContainer == (Object)null)
			{
				Debug.LogWarning((object)"Coroutine container not configured... did you forget to call Init?");
				return;
			}
			StopTween();
			if (!((Component)m_CoroutineContainer).gameObject.activeInHierarchy)
			{
				info.TweenValue(1f);
				return;
			}
			m_Tween = Start(info);
			m_CoroutineContainer.StartCoroutine(m_Tween);
		}

		public void StopTween()
		{
			if (m_Tween != null)
			{
				m_CoroutineContainer.StopCoroutine(m_Tween);
				m_Tween = null;
			}
		}
	}
	[BepInPlugin("com.KingEnderBrine.ItemDisplayPlacementHelper", "Item Display Placement Helper", "1.8.2")]
	public class ItemDisplayPlacementHelperPlugin : BaseUnityPlugin
	{
		public const string Guid = "com.KingEnderBrine.ItemDisplayPlacementHelper";

		public const string Name = "Item Display Placement Helper";

		public const string Version = "1.8.2";

		internal static ItemDisplayPlacementHelperPlugin Instance { get; private set; }

		internal static ManualLogSource InstanceLogger
		{
			get
			{
				ItemDisplayPlacementHelperPlugin instance = Instance;
				if (instance == null)
				{
					return null;
				}
				return ((BaseUnityPlugin)instance).Logger;
			}
		}

		private void Awake()
		{
			Instance = this;
			NativeHelpers.Init();
			AssetsHelper.LoadAssetBundle();
			ConfigHelper.InitConfigs(((BaseUnityPlugin)this).Config);
		}

		private void OnDestroy()
		{
			Instance = null;
		}

		private void Update()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (Input.GetKeyDown((KeyCode)283))
			{
				Scene activeScene = SceneManager.GetActiveScene();
				if (((Scene)(ref activeScene)).name == "title")
				{
					((MonoBehaviour)this).StartCoroutine(StartSceneCoroutine());
				}
			}
		}

		private IEnumerator StartSceneCoroutine()
		{
			if (!(NetworkManager.networkSceneName == "KingEnderBrine_IDRS_Editor"))
			{
				Console.instance.SubmitCmd((NetworkUser)null, "host 0", false);
				yield return (object)new WaitUntil((Func<bool>)(() => (Object)(object)PreGameController.instance != (Object)null));
				NetworkManager.singleton.ServerChangeScene("KingEnderBrine_IDRS_Editor");
				if (Object.op_Implicit((Object)(object)ConsoleWindow.instance))
				{
					Object.Destroy((Object)(object)((Component)ConsoleWindow.instance).gameObject);
				}
			}
		}
	}
	public class ItemDisplayRulePreviewController : MonoBehaviour
	{
		[NonSerialized]
		[HideInInspector]
		public EditableItemDisplayRule itemDisplayRule;

		[SerializeField]
		private TMP_Text textComponent;

		[SerializeField]
		private Button buttonComponent;

		private void Update()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			ItemDisplayRuleType ruleType = itemDisplayRule.ruleType;
			if ((int)ruleType != 0)
			{
				if ((int)ruleType == 1)
				{
					textComponent.text = "LimbMask";
				}
			}
			else
			{
				textComponent.text = (Object.op_Implicit((Object)(object)itemDisplayRule.followerPrefab) ? ((Object)itemDisplayRule.followerPrefab).name : "No prefab");
			}
			((Selectable)buttonComponent).interactable = ParentedPrefabDisplayController.Instance.ItemDisplayRule != itemDisplayRule;
		}

		public void EditItemDisplayRule()
		{
			ParentedPrefabDisplayController.Instance.SetItemDisplayRule(itemDisplayRule);
		}
	}
	public class ItemDisplayRuleSetController : MonoBehaviour
	{
		public GameObject rowPrefab;

		public Transform container;

		[Space]
		public Button enableAllButton;

		public Button disableAllButton;

		public TMP_InputField searchInput;

		public TMP_Dropdown showItemsMode;

		[Space]
		public Button addButton;

		public Button deleteButton;

		public Button importButton;

		public Button exportButton;

		private readonly List<DisplayRuleGroupPreviewController> previewRows = new List<DisplayRuleGroupPreviewController>();

		private readonly HashSet<Object> notPickedAssets = new HashSet<Object>();

		private CharacterModel characterModel;

		private EditableItemDisplayRuleSet itemDisplayRuleSet;

		private string filter;

		private Dictionary<string, string> pathToGuid;

		private Dictionary<string, AssetBundle> dirToBundle;

		private Dictionary<AssetBundle, Dictionary<int, string>> bundleToAssets;

		public static ItemDisplayRuleSetController Instance { get; private set; }

		private void Awake()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			showItemsMode.AddOptions((from el in (IEnumerable<ReadOnlyContentPack>)(object)ContentManager.allLoadedContentPacks
				where ((IEnumerable<EquipmentDef>)(object)((ReadOnlyContentPack)(ref el)).equipmentDefs).Any() || ((IEnumerable<ItemDef>)(object)((ReadOnlyContentPack)(ref el)).itemDefs).Any()
				select ((ReadOnlyContentPack)(ref el)).identifier).ToList());
			ModelPicker.OnModelChanged += OnModelChanged;
			ModelPicker.OnModelWillChange += OnModelWillChange;
		}

		private void OnDestroy()
		{
			Instance = null;
			ModelPicker.OnModelChanged -= OnModelChanged;
			ModelPicker.OnModelWillChange -= OnModelWillChange;
		}

		private void Update()
		{
			((Selectable)enableAllButton).interactable = Object.op_Implicit((Object)(object)characterModel);
			((Selectable)disableAllButton).interactable = Object.op_Implicit((Object)(object)characterModel);
			((Selectable)searchInput).interactable = Object.op_Implicit((Object)(object)characterModel);
			((Selectable)showItemsMode).interactable = Object.op_Implicit((Object)(object)characterModel);
			((Selectable)addButton).interactable = Object.op_Implicit((Object)(object)characterModel);
			((Selectable)deleteButton).interactable = Object.op_Implicit((Object)(object)characterModel) && DisplayRuleGroupEditingController.Instance.DisplayRuleGroup != null;
			((Selectable)importButton).interactable = Object.op_Implicit((Object)(object)characterModel);
			((Selectable)exportButton).interactable = Object.op_Implicit((Object)(object)characterModel);
		}

		private void OnModelChanged(CharacterModel characterModel)
		{
			if (!Object.op_Implicit((Object)(object)characterModel))
			{
				return;
			}
			this.characterModel = characterModel;
			itemDisplayRuleSet = EditableItemDisplayRuleSet.From(characterModel.itemDisplayRuleSet);
			ItemDef[] itemDefs = ItemCatalog.itemDefs;
			foreach (ItemDef item in itemDefs)
			{
				notPickedAssets.Add((Object)(object)item);
			}
			EquipmentDef[] equipmentDefs = EquipmentCatalog.equipmentDefs;
			foreach (EquipmentDef item2 in equipmentDefs)
			{
				notPickedAssets.Add((Object)(object)item2);
			}
			foreach (EditableDisplayRuleGroup displayRuleGroup in itemDisplayRuleSet.DisplayRuleGroups)
			{
				notPickedAssets.Remove(displayRuleGroup.KeyAsset);
				CreateRowInstance(displayRuleGroup);
			}
			ApplyFilter(filter);
		}

		private void OnModelWillChange()
		{
			foreach (DisplayRuleGroupPreviewController previewRow in previewRows)
			{
				Object.Destroy((Object)(object)((Component)previewRow).gameObject);
			}
			previewRows.Clear();
			characterModel = null;
		}

		private void CreateRowInstance(EditableDisplayRuleGroup displayRuleGroup)
		{
			GameObject obj = Object.Instantiate<GameObject>(rowPrefab, container);
			DisplayRuleGroupPreviewController component = obj.GetComponent<DisplayRuleGroupPreviewController>();
			component.displayRuleGroup = displayRuleGroup;
			(component.icon, component.nameText) = GetItemInfo(displayRuleGroup.KeyAsset);
			obj.SetActive(true);
			previewRows.Add(component);
		}

		private (Sprite, string) GetItemInfo(Object keyAsset)
		{
			ItemDef val = (ItemDef)(object)((keyAsset is ItemDef) ? keyAsset : null);
			if (val != null)
			{
				return (val.pickupIconSprite, Language.GetString(val.nameToken));
			}
			EquipmentDef val2 = (EquipmentDef)(object)((keyAsset is EquipmentDef) ? keyAsset : null);
			if (val2 != null)
			{
				return (val2.pickupIconSprite, Language.GetString(val2.nameToken));
			}
			return default((Sprite, string));
		}

		public void ApplyFilter(string newFilter)
		{
			filter = newFilter;
			UpdateRowsVisibility();
		}

		public void ChangeShowMode(int value)
		{
			UpdateRowsVisibility();
		}

		public void EnableAll()
		{
			foreach (DisplayRuleGroupPreviewController previewRow in previewRows)
			{
				if (((Component)previewRow).gameObject.activeSelf)
				{
					previewRow.ToggleDisplay(display: true);
				}
			}
			characterModel.UpdateMaterials();
		}

		public void DisableAll()
		{
			foreach (DisplayRuleGroupPreviewController previewRow in previewRows)
			{
				if (((Component)previewRow).gameObject.activeSelf)
				{
					previewRow.ToggleDisplay(display: false);
				}
			}
		}

		public void Add()
		{
			DialogController.ShowKeyAssetPicker(notPickedAssets, delegate(Object asset)
			{
				EditableDisplayRuleGroup editableDisplayRuleGroup = new EditableDisplayRuleGroup
				{
					KeyAsset = asset
				};
				itemDisplayRuleSet.DisplayRuleGroups.Add(editableDisplayRuleGroup);
				notPickedAssets.Remove(asset);
				CreateRowInstance(editableDisplayRuleGroup);
				ApplyFilter(filter);
			});
		}

		public void Delete()
		{
			EditableDisplayRuleGroup displayRuleGroup = DisplayRuleGroupEditingController.Instance.DisplayRuleGroup;
			for (int i = 0; i < previewRows.Count; i++)
			{
				DisplayRuleGroupPreviewController displayRuleGroupPreviewController = previewRows[i];
				if (displayRuleGroupPreviewController.displayRuleGroup == displayRuleGroup)
				{
					notPickedAssets.Add(displayRuleGroup.KeyAsset);
					displayRuleGroupPreviewController.ToggleDisplay(display: false);
					itemDisplayRuleSet.DisplayRuleGroups.RemoveAt(i);
					previewRows.RemoveAt(i);
					Object.Destroy((Object)(object)((Component)displayRuleGroupPreviewController).gameObject);
					break;
				}
			}
		}

		public void Export()
		{
			DialogController.ShowExport(delegate(string path, AssetsToExport assetsToExport, bool generateClass, string @namespace, bool withSkin)
			{
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Expected O, but got Unknown
				//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0100: Expected O, but got Unknown
				//IL_012f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Expected O, but got Unknown
				//IL_017d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0182: Unknown result type (might be due to invalid IL or missing references)
				//IL_018b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0190: Unknown result type (might be due to invalid IL or missing references)
				//IL_0199: Unknown result type (might be due to invalid IL or missing references)
				//IL_019e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0215: Unknown result type (might be due to invalid IL or missing references)
				//IL_021a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0223: Unknown result type (might be due to invalid IL or missing references)
				//IL_0228: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					bool anyAssetBundle = false;
					bool refreshBundles = true;
					IEnumerable<DisplayRuleGroupPreviewController> enumerable = assetsToExport switch
					{
						AssetsToExport.All => previewRows, 
						AssetsToExport.Filtered => previewRows.Where((DisplayRuleGroupPreviewController r) => ((Component)r).gameObject.activeSelf), 
						AssetsToExport.Enabled => previewRows.Where((DisplayRuleGroupPreviewController r) => ((Component)r).gameObject.activeSelf && r.displayRuleGroup.Enabled), 
						_ => throw new NotSupportedException(), 
					};
					ExportItemDisplayRuleSet val = new ExportItemDisplayRuleSet();
					val.bodyName = ModelPicker.Instance.ModelInfo.bodyName;
					if (withSkin)
					{
						ModelSkinController modelSkinController = ModelPicker.Instance.ModelSkinController;
						SkinDef safe = ArrayUtils.GetSafe<SkinDef>(modelSkinController.skins, modelSkinController.currentSkinIndex);
						val.skinName = (Object.op_Implicit((Object)(object)safe) ? ((Object)safe).name : "");
					}
					foreach (DisplayRuleGroupPreviewController item in enumerable)
					{
						EditableDisplayRuleGroup displayRuleGroup = item.displayRuleGroup;
						ExportKeyAssetRuleGroup val2 = new ExportKeyAssetRuleGroup();
						val2.name = displayRuleGroup.KeyAsset.name;
						foreach (EditableItemDisplayRule rule in displayRuleGroup.Rules)
						{
							ExportItemDisplayRule val3 = new ExportItemDisplayRule();
							if (FillPrefabReference(rule, refreshBundles))
							{
								refreshBundles = false;
							}
							AssetReferenceGameObject followerPrefabAddress = rule.followerPrefabAddress;
							val3.guid = ((followerPrefabAddress != null) ? ((AssetReference)followerPrefabAddress).AssetGUID : null);
							val3.assetBundle = rule.assetBundle;
							val3.assetPath = rule.assetPath;
							val3.localScale = rule.localScale;
							val3.localPos = rule.localPos;
							val3.localAngles = rule.localAngles;
							val3.childName = rule.childName;
							if (!string.IsNullOrEmpty(rule.childName) && rule.childName.EndsWith(StringHelpers.NamePostfix))
							{
								CharacterModel val4 = ModelPicker.Instance.CharacterModel;
								Transform val5 = val4.childLocator.FindChild(val3.childName);
								if (Object.op_Implicit((Object)(object)val5))
								{
									val3.childPath = Utils.GetChildPath(((Component)val4).transform, val5);
								}
							}
							val3.limbMask = rule.limbMask;
							val3.ruleType = rule.ruleType;
							if (!string.IsNullOrEmpty(val3.assetBundle))
							{
								anyAssetBundle = true;
							}
							val2.rules.Add(val3);
						}
						if (displayRuleGroup.KeyAsset is ItemDef)
						{
							val.itemGroups.Add(val2);
						}
						else if (displayRuleGroup.KeyAsset is EquipmentDef)
						{
							val.equipmentGroups.Add(val2);
						}
					}
					val.itemGroups.Sort((ExportKeyAssetRuleGroup a, ExportKeyAssetRuleGroup b) => StringComparer.Ordinal.Compare(a.name, b.name));
					val.equipmentGroups.Sort((ExportKeyAssetRuleGroup a, ExportKeyAssetRuleGroup b) => StringComparer.Ordinal.Compare(a.name, b.name));
					string contents = JsonUtility.ToJson((object)val, true);
					File.WriteAllText(path, contents);
					if (generateClass)
					{
						string contents2 = GenerateClass(val, @namespace, Path.GetFileNameWithoutExtension(path), anyAssetBundle);
						File.WriteAllText(Path.ChangeExtension(path, ".cs"), contents2);
					}
				}
				catch (Exception ex)
				{
					ItemDisplayPlacementHelperPlugin.InstanceLogger.LogError((object)ex);
					DialogController.ShowError("Export failed, check log.");
				}
			});
		}

		private string GenerateClass(ExportItemDisplayRuleSet idrs, string @namespace, string @class, bool anyAssetBundle)
		{
			StringBuilder stringBuilder = new StringBuilder();
			int i = 0;
			stringBuilder.A("using System;").L(i).A("using System.Collections.Generic;")
				.L(i)
				.A("using RoR2;")
				.L(i)
				.A("using UnityEngine;")
				.L(i)
				.A("using UnityEngine.AddressableAssets;")
				.L(0);
			if (!string.IsNullOrEmpty(@namespace))
			{
				stringBuilder.L(i).A("namespace ").A(@namespace)
					.StartBlock(ref i);
			}
			stringBuilder.L(i).A("public class ").A(@class)
				.StartBlock(ref i);
			if (anyAssetBundle)
			{
				stringBuilder.L(i).A("private partial AssetBundle GetAssetBundle(string name);").L(0);
			}
			stringBuilder.L(i).A("public ItemDisplayRuleSet Create()").StartBlock(ref i)
				.L(i)
				.A("var idrs = ScriptableObject.CreateInstance<ItemDisplayRuleSet>();")
				.L(i)
				.A("ReplaceRules(idrs);")
				.L(i)
				.A("return idrs;")
				.EndBlock(ref i)
				.L(0)
				.L(i)
				.A("public void ReplaceRules(ItemDisplayRuleSet idrs)")
				.StartBlock(ref i)
				.L(i)
				.A("var existingGroupsLength = idrs.keyAssetRuleGroups.Length;")
				.L(i)
				.A("var newRules = new List<ItemDisplayRuleSet.KeyAssetRuleGroup>();");
			foreach (ExportKeyAssetRuleGroup itemGroup in idrs.itemGroups)
			{
				GenerateRuleText(stringBuilder, itemGroup, "Item");
			}
			foreach (ExportKeyAssetRuleGroup equipmentGroup in idrs.equipmentGroups)
			{
				GenerateRuleText(stringBuilder, equipmentGroup, "Equipment");
			}
			stringBuilder.L(i).A("if (newRules.Count > 0)").StartBlock(ref i)
				.L(i)
				.A("Array.Resize(ref idrs.keyAssetRuleGroups, existingGroupsLength + newRules.Count);")
				.L(i)
				.A("for (var i = 0; i < newRules.Count; i++)")
				.StartBlock(ref i)
				.L(i)
				.A("idrs.keyAssetRuleGroups[existingGroupsLength + i] = newRules[i];")
				.EndBlock(ref i)
				.EndBlock(ref i)
				.L(0)
				.L(0)
				.L(i)
				.A("void AddOrReplaceGroup(ItemDisplayRuleSet.KeyAssetRuleGroup group)")
				.StartBlock(ref i)
				.L(i)
				.A("for (var i = 0; i < existingGroupsLength; i++)")
				.StartBlock(ref i)
				.L(i)
				.A("if (idrs.keyAssetRuleGroups[i].keyAsset == group.keyAsset)")
				.StartBlock(ref i)
				.L(i)
				.A("idrs.keyAssetRuleGroups[i] = group;")
				.L(i)
				.A("return;")
				.EndBlock(ref i)
				.EndBlock(ref i)
				.L(0)
				.L(i)
				.A("newRules.Add(group);")
				.EndBlock(ref i)
				.EndBlock(ref i)
				.L(0)
				.L(i)
				.A("private static ItemDisplayRule ParentedPrefabAddressables(string guid, string childName, Vector3 localPos, Vector3 localAngles, Vector3 localScale)")
				.StartBlock(ref i)
				.L(i)
				.A("return new ItemDisplayRule")
				.StartBlock(ref i)
				.L(i)
				.A("ruleType = ItemDisplayRuleType.ParentedPrefab,")
				.L(i)
				.A("followerPrefabAddress = new AssetReferenceGameObject(guid),")
				.L(i)
				.A("childName = childName,")
				.L(i)
				.A("localPos = localPos,")
				.L(i)
				.A("localAngles = localAngles,")
				.L(i)
				.A("localScale = localScale,")
				.EndBlock(ref i)
				.A(");")
				.EndBlock(ref i)
				.L(0)
				.L(i)
				.A("private static ItemDisplayRule ParentedPrefabAssetBundle(AssetBundle assetBundle, string assetPath, string childName, Vector3 localPos, Vector3 localAngles, Vector3 localScale)")
				.StartBlock(ref i)
				.L(i)
				.A("return new ItemDisplayRule")
				.StartBlock(ref i)
				.L(i)
				.A("ruleType = ItemDisplayRuleType.ParentedPrefab,")
				.L(i)
				.A("followerPrefab = assetBundle.LoadAsset<GameObject>(assetPath),")
				.L(i)
				.A("followerPrefabAddress = new AssetReferenceGameObject(\"\"),")
				.L(i)
				.A("childName = childName,")
				.L(i)
				.A("localPos = localPos,")
				.L(i)
				.A("localAngles = localAngles,")
				.L(i)
				.A("localScale = localScale,")
				.EndBlock(ref i)
				.EndBlock(ref i)
				.L(0)
				.L(i)
				.A("private static ItemDisplayRule LimbMask(LimbFlags limbMask)")
				.StartBlock(ref i)
				.L(i)
				.A("return new ItemDisplayRule")
				.StartBlock(ref i)
				.L(i)
				.A("ruleType = ItemDisplayRuleType.LimbMask,")
				.L(i)
				.A("limbMask = limbMask,")
				.EndBlock(ref i)
				.A(");")
				.EndBlock(ref i)
				.L(0)
				.L(i)
				.A("private static ItemDef GetItemDef(string itemDefName) => ItemCatalog.GetItemDef(ItemCatalog.FindItemIndex(itemDefName));")
				.L(i)
				.A("private static EquipmentDef GetEquipmentDef(string equipmentDefName) => EquipmentCatalog.GetEquipmentDef(EquipmentCatalog.FindEquipmentIndex(equipmentDefName));")
				.EndBlock(ref i);
			if (!string.IsNullOrEmpty(@namespace))
			{
				stringBuilder.EndBlock(ref i);
			}
			return stringBuilder.ToString();
			void GenerateRuleText(StringBuilder sb, ExportKeyAssetRuleGroup group, string type)
			{
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Invalid comparison between Unknown and I4
				//IL_0229: Unknown result type (might be due to invalid IL or missing references)
				//IL_019e: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
				sb.L(i).A("AddOrReplaceGroup(new ItemDisplayRuleSet.KeyAssetRuleGroup").StartBlock(ref i)
					.L(i)
					.A("keyAsset = Get")
					.A(type)
					.A("Def(\"")
					.A(group.name)
					.A("\"),")
					.L(i)
					.A("displayRuleGroup =")
					.StartBlock(ref i);
				if (group.rules.Count == 0)
				{
					sb.L(i).A("rules = Array.Empty<ItemDisplayRule>()");
				}
				else
				{
					sb.L(i).A("rules = new[]").StartBlock(ref i);
					foreach (ExportItemDisplayRule rule in group.rules)
					{
						ItemDisplayRuleType ruleType = rule.ruleType;
						if ((int)ruleType != 0)
						{
							if ((int)ruleType == 1)
							{
								sb.L(i).A("LimbMask(").A(TemplateHelpers.EnumFlagsValue<LimbFlags>(rule.limbMask, ""))
									.A("),");
							}
						}
						else
						{
							sb.L(i);
							if (!string.IsNullOrEmpty(rule.guid))
							{
								sb.A("ParentedPrefabAddressables(").A(TemplateHelpers.StringText(rule.guid, ""));
							}
							else
							{
								sb.A("ParentedPrefabAssetBundle(GetAssetBundle(").A(TemplateHelpers.StringText(rule.assetBundle, "")).A("), ")
									.A(TemplateHelpers.StringText(rule.assetPath, ""));
							}
							sb.A(", ").A(TemplateHelpers.StringText(rule.childName, "")).A(", ")
								.A(TemplateHelpers.Vector3Text(rule.localPos, 10, "", ""))
								.A(", ")
								.A(TemplateHelpers.Vector3Text(rule.localAngles, 10, "", ""))
								.A(", ")
								.A(TemplateHelpers.Vector3Text(rule.localScale, 10, "", ""))
								.A("),");
						}
					}
					sb.EndBlock(ref i);
				}
				sb.EndBlock(ref i).EndBlock(ref i).A(");");
			}
		}

		public void Import()
		{
			DialogController.ShowImport(delegate(string path, ImportType importType)
			{
				//IL_0101: Unknown result type (might be due to invalid IL or missing references)
				//IL_018c: Unknown result type (might be due to invalid IL or missing references)
				//IL_01de: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e8: Expected O, but got Unknown
				try
				{
					ExportItemDisplayRuleSet val = JsonUtility.FromJson<ExportItemDisplayRuleSet>(File.ReadAllText(path));
					DisableAll();
					if (importType == ImportType.ReplaceSet)
					{
						for (int i = 0; i < previewRows.Count; i++)
						{
							DisplayRuleGroupPreviewController displayRuleGroupPreviewController = previewRows[i];
							notPickedAssets.Add(displayRuleGroupPreviewController.displayRuleGroup.KeyAsset);
							Object.Destroy((Object)(object)((Component)displayRuleGroupPreviewController).gameObject);
						}
						itemDisplayRuleSet.DisplayRuleGroups.Clear();
						previewRows.Clear();
					}
					Dictionary<string, AssetBundle> allBundles = AssetBundle.GetAllLoadedAssetBundles().ToDictionary((AssetBundle b) => ((Object)b).name);
					HashSet<string> childNames = characterModel.childLocator.transformPairs.Select((NameTransformPair p) => p.name).ToHashSet();
					new List<KeyAssetRuleGroup>();
					foreach (ExportKeyAssetRuleGroup itemGroup in val.itemGroups)
					{
						ItemDef itemDef = ItemCatalog.GetItemDef(ItemCatalog.FindItemIndex(itemGroup.name));
						if (!Object.op_Implicit((Object)(object)itemDef))
						{
							ItemDisplayPlacementHelperPlugin.InstanceLogger.LogError((object)("Couldn't get ItemDef name=\"" + itemGroup.name + "\""));
						}
						else
						{
							EditableDisplayRuleGroup editableDisplayRuleGroup = MapGroup(allBundles, childNames, itemGroup);
							editableDisplayRuleGroup.KeyAsset = (Object)(object)itemDef;
							AddKeyAsset(editableDisplayRuleGroup);
						}
					}
					foreach (ExportKeyAssetRuleGroup equipmentGroup in val.equipmentGroups)
					{
						EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(EquipmentCatalog.FindEquipmentIndex(equipmentGroup.name));
						if (!Object.op_Implicit((Object)(object)equipmentDef))
						{
							ItemDisplayPlacementHelperPlugin.InstanceLogger.LogError((object)("Couldn't get EquipmentDef name=\"" + equipmentGroup.name + "\""));
						}
						else
						{
							EditableDisplayRuleGroup editableDisplayRuleGroup2 = MapGroup(allBundles, childNames, equipmentGroup);
							editableDisplayRuleGroup2.KeyAsset = (Object)(object)equipmentDef;
							editableDisplayRuleGroup2.KeyAssetAddress = new IDRSKeyAssetReference("");
							AddKeyAsset(editableDisplayRuleGroup2);
						}
					}
					ApplyFilter(filter);
				}
				catch (Exception ex)
				{
					ItemDisplayPlacementHelperPlugin.InstanceLogger.LogError((object)ex);
					DialogController.ShowError("Import failed, check log.");
				}
			});
			void AddKeyAsset(EditableDisplayRuleGroup displayGroup)
			{
				for (int i = 0; i < itemDisplayRuleSet.DisplayRuleGroups.Count; i++)
				{
					if (itemDisplayRuleSet.DisplayRuleGroups[i].KeyAsset == displayGroup.KeyAsset)
					{
						itemDisplayRuleSet.DisplayRuleGroups[i] = displayGroup;
						previewRows[i].displayRuleGroup = displayGroup;
						return;
					}
				}
				itemDisplayRuleSet.DisplayRuleGroups.Add(displayGroup);
				notPickedAssets.Remove(displayGroup.KeyAsset);
				CreateRowInstance(displayGroup);
			}
			static EditableDisplayRuleGroup MapGroup(Dictionary<string, AssetBundle> allBundles, HashSet<string> childNames, ExportKeyAssetRuleGroup ruleGroup)
			{
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: Unknown result type (might be due to invalid IL or missing references)
				//IL_0106: Unknown result type (might be due to invalid IL or missing references)
				//IL_011b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Expected O, but got Unknown
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Expected O, but got Unknown
				EditableDisplayRuleGroup editableDisplayRuleGroup = new EditableDisplayRuleGroup();
				for (int i = 0; i < ruleGroup.rules.Count; i++)
				{
					ExportItemDisplayRule val = ruleGroup.rules[i];
					string text = val.childName;
					if (!string.IsNullOrEmpty(val.childPath))
					{
						Transform val2 = ((Component)ModelPicker.Instance.CharacterModel).transform.Find(val.childPath);
						if (Object.op_Implicit((Object)(object)val2))
						{
							text = StringHelpers.ChildNameFromPath(val.childPath);
							ChildLocator childLocator = ModelPicker.Instance.CharacterModel.childLocator;
							if (!Object.op_Implicit((Object)(object)childLocator.FindChild(text)))
							{
								ref NameTransformPair[] transformPairs = ref childLocator.transformPairs;
								NameTransformPair val3 = new NameTransformPair
								{
									name = text,
									transform = val2
								};
								ArrayUtils.ArrayAppend<NameTransformPair>(ref transformPairs, ref val3);
								ParentedPrefabDisplayController.Instance.childNameDropdown.options.Add(new OptionData(text));
							}
						}
					}
					EditableItemDisplayRule editableItemDisplayRule = new EditableItemDisplayRule
					{
						childName = text,
						ruleType = val.ruleType,
						limbMask = val.limbMask,
						localAngles = val.localAngles,
						localPos = val.localPos,
						localScale = val.localScale,
						followerPrefabAddress = new AssetReferenceGameObject(val.guid ?? "")
					};
					if (!string.IsNullOrEmpty(val.assetBundle))
					{
						AssetBundle val4 = allBundles[val.assetBundle];
						editableItemDisplayRule.followerPrefab = val4.LoadAsset<GameObject>(val.assetPath);
						if (Object.op_Implicit((Object)(object)editableItemDisplayRule.followerPrefab))
						{
							editableItemDisplayRule.assetBundle = val.assetBundle;
							editableItemDisplayRule.assetPath = val.assetPath;
							editableItemDisplayRule.referenceDiscovered = true;
						}
					}
					else
					{
						AssetReferenceGameObject followerPrefabAddress = editableItemDisplayRule.followerPrefabAddress;
						if (followerPrefabAddress != null && ((AssetReference)followerPrefabAddress).RuntimeKeyIsValid())
						{
							editableItemDisplayRule.referenceDiscovered = true;
						}
					}
					editableDisplayRuleGroup.Rules.Add(editableItemDisplayRule);
				}
				return editableDisplayRuleGroup;
			}
		}

		public bool FillPrefabReference(EditableItemDisplayRule rule, bool refreshBundles)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			if (rule.referenceDiscovered)
			{
				return false;
			}
			rule.referenceDiscovered = true;
			if (!Object.op_Implicit((Object)(object)rule.followerPrefab))
			{
				return false;
			}
			(string guid, string assetBundle, string path) prefabReference = GetPrefabReference(rule.followerPrefab, refreshBundles);
			string item = prefabReference.guid;
			string item2 = prefabReference.assetBundle;
			string item3 = prefabReference.path;
			rule.followerPrefabAddress = new AssetReferenceGameObject(item);
			rule.assetBundle = item2;
			rule.assetPath = item3;
			return true;
		}

		public (string guid, string assetBundle, string path) GetPrefabReference(GameObject go, bool refreshBundles)
		{
			if (pathToGuid == null)
			{
				Regex guidRegex = new Regex("^[0-9a-f]{32}$", RegexOptions.Compiled);
				IResourceLocator? obj = Addressables.ResourceLocators.FirstOrDefault((Func<IResourceLocator, bool>)((IResourceLocator l) => l.LocatorId == "AddressablesMainContentCatalog"));
				ResourceLocationMap val = (ResourceLocationMap)(object)((obj is ResourceLocationMap) ? obj : null);
				pathToGuid = (from l in val.Locations
					where l.Key is string { Length: 32 } text && guidRegex.IsMatch(text)
					where l.Value[0].ResourceType.IsAssignableFrom(typeof(GameObject))
					select l).ToDictionary<KeyValuePair<object, IList<IResourceLocation>>, string, string>((KeyValuePair<object, IList<IResourceLocation>> l) => l.Value[0].InternalId, (KeyValuePair<object, IList<IResourceLocation>> l) => l.Key as string, StringComparer.OrdinalIgnoreCase);
			}
			if (dirToBundle == null || refreshBundles)
			{
				if (dirToBundle == null)
				{
					dirToBundle = new Dictionary<string, AssetBundle>();
				}
				IEnumerable<AssetBundle> allLoadedAssetBundles = AssetBundle.GetAllLoadedAssetBundles();
				new Dictionary<AssetBundle, Dictionary<int, string>>();
				foreach (AssetBundle item in allLoadedAssetBundles)
				{
					foreach (string bundleDirectory in NativeHelpers.GetBundleDirectories(item))
					{
						dirToBundle["archive:/" + bundleDirectory + "/" + bundleDirectory] = item;
					}
				}
			}
			int instanceID = ((Object)go).GetInstanceID();
			string pathName = NativeHelpers.GetPathName(instanceID);
			if (dirToBundle.TryGetValue(pathName, out var value))
			{
				if (bundleToAssets == null)
				{
					bundleToAssets = new Dictionary<AssetBundle, Dictionary<int, string>>();
				}
				if (!bundleToAssets.TryGetValue(value, out var value2))
				{
					value2 = (bundleToAssets[value] = NativeHelpers.GetBundleContainerPaths(value));
				}
				if (value2.TryGetValue(instanceID, out var value3))
				{
					string name = ((Object)value).name;
					if (name.EndsWith(".bundle") && pathToGuid.TryGetValue(value3, out var value4))
					{
						return (guid: value4, assetBundle: null, path: null);
					}
					return (guid: null, assetBundle: name, path: value3);
				}
			}
			return default((string, string, string));
		}

		private void UpdateRowsVisibility()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			bool flag = string.IsNullOrEmpty(filter);
			string identifier = showItemsMode.options[showItemsMode.value].text;
			ReadOnlyContentPack[] array = ((showItemsMode.value > 0) ? ((IEnumerable<ReadOnlyContentPack>)(object)ContentManager.allLoadedContentPacks).Where((ReadOnlyContentPack p) => ((ReadOnlyContentPack)(ref p)).identifier == identifier).ToArray() : null);
			foreach (DisplayRuleGroupPreviewController previewRow in previewRows)
			{
				bool flag2 = flag || previewRow.nameText.ContainsInSequence(filter);
				if (flag2 && array != null)
				{
					Object keyAsset = previewRow.displayRuleGroup.KeyAsset;
					ItemDef itemDef = (ItemDef)(object)((keyAsset is ItemDef) ? keyAsset : null);
					if (itemDef != null)
					{
						flag2 = array.Any((ReadOnlyContentPack p) => ((ReadOnlyContentPack)(ref p)).itemDefs.Contains(itemDef));
					}
					else
					{
						keyAsset = previewRow.displayRuleGroup.KeyAsset;
						EquipmentDef equipmentDef = (EquipmentDef)(object)((keyAsset is EquipmentDef) ? keyAsset : null);
						if (equipmentDef != null)
						{
							flag2 = array.Any((ReadOnlyContentPack p) => ((ReadOnlyContentPack)(ref p)).equipmentDefs.Contains(equipmentDef));
						}
					}
				}
				((Component)previewRow).gameObject.SetActive(flag2);
			}
		}
	}
	public class KeyAssetRowController : MonoBehaviour
	{
		public TMP_Text text;

		public TMP_Text subText;

		public Image icon;

		public Button button;

		[NonSerialized]
		public Object keyAsset;
	}
	public class LayoutElementHeightFromTarget : LayoutElement
	{
		public float maxHeight = -1f;

		public RectTransform target;

		public override float preferredHeight
		{
			get
			{
				//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)
				Rect rect = target.rect;
				float height = ((Rect)(ref rect)).height;
				if (maxHeight != -1f && Object.op_Implicit((Object)(object)target))
				{
					if (!(height > maxHeight))
					{
						return height;
					}
					return maxHeight;
				}
				return height;
			}
			set
			{
				((LayoutElement)this).preferredHeight = value;
			}
		}
	}
	public class MatchLocalScale : MonoBehaviour
	{
		public Transform target;

		private void Update()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)target))
			{
				((Component)this).transform.localScale = target.localScale;
			}
		}
	}
	public class ModelPicker : MonoBehaviour
	{
		public delegate void OnModelChangedHandler(CharacterModel characterModel);

		public SearchableDropdown dropdown;

		public TMP_Dropdown skinsDropdown;

		public Transform modelSpawnPosition;

		[Space]
		public RawImage icon;

		public TextMeshProUGUI bodyNameText;

		public TextMeshProUGUI modelNameText;

		private ReverseSkin reverseSkin;

		private List<SearchableDropdown.OptionData> allBodyOptions;

		private List<SearchableDropdown.OptionData> logbookBodyOptions;

		public ModelPrefabInfo ModelInfo { get; private set; }

		public GameObject ModelInstance { get; private set; }

		public CharacterModel CharacterModel { get; private set; }

		public ModelSkinController ModelSkinController { get; private set; }

		public Dictionary<SkinnedMeshRenderer, MeshCollider> CachedSkinnedMeshRenderers { get; } = new Dictionary<SkinnedMeshRenderer, MeshCollider>();

		public static ModelPicker Instance { get; private set; }

		public static event OnModelChangedHandler OnModelChanged;

		public static event Action OnModelWillChange;

		private void Awake()
		{
			Instance = this;
			logbookBodyOptions = MapBodiesToOptions(SurvivorCatalog.orderedSurvivorDefs.Select((SurvivorDef survivorDef) => BodyCatalog.GetBodyPrefabBodyComponent(SurvivorCatalog.GetBodyIndexFromSurvivorIndex(survivorDef.survivorIndex))).Union(BodyCatalog.allBodyPrefabBodyBodyComponents.Where((CharacterBody characterBody) => Object.op_Implicit((Object)(object)characterBody) && Object.op_Implicit((Object)(object)((Component)characterBody).GetComponent<DeathRewards>()?.logUnlockableDef))));
			allBodyOptions = MapBodiesToOptions(BodyCatalog.allBodyPrefabBodyBodyComponents);
			dropdown.Options = logbookBodyOptions;
			((UnityEvent<object>)(dropdown.OnItemSelected ?? (dropdown.OnItemSelected = new SearchableDropdown.DropdownEvent()))).AddListener((UnityAction<object>)SelectModel);
			static List<SearchableDropdown.OptionData> MapBodiesToOptions(IEnumerable<CharacterBody> bodies)
			{
				return (from characterBody in bodies
					select (characterBody: characterBody, characterModel: ((Component)characterBody).GetComponentInChildren<CharacterModel>()) into el
					where Object.op_Implicit((Object)(object)el.characterModel)
					select el).Select(delegate((CharacterBody characterBody, CharacterModel characterModel) el)
				{
					ModelPrefabInfo modelPrefabInfo = new ModelPrefabInfo
					{
						modelPrefab = ((Component)el.characterModel).gameObject,
						bodyName = ((Object)el.characterBody).name,
						modelName = ((Object)el.characterModel).name,
						localizedBodyName = Language.GetString(el.characterBody.baseNameToken ?? ((Object)el.characterBody).name),
						characterBody = el.characterBody
					};
					return new SearchableDropdown.OptionData(modelPrefabInfo, modelPrefabInfo.localizedBodyName + " || " + modelPrefabInfo.bodyName + " || " + modelPrefabInfo.modelName);
				}).ToList();
			}
		}

		private void OnDestroy()
		{
			Instance = null;
		}

		public void SelectModel(object modelInfo)
		{
			((MonoBehaviour)this).StartCoroutine(SelectModelAsync(modelInfo));
		}

		public IEnumerator SelectModelAsync(object modelInfo)
		{
			if (modelInfo as ModelPrefabInfo != ModelInfo)
			{
				ModelPicker.OnModelWillChange?.Invoke();
				DestroyModelInstance();
				ModelInfo = modelInfo as ModelPrefabInfo;
				yield return BuildModelInstance();
				ConfigureSkinVariants();
				ModelPicker.OnModelChanged?.Invoke(CharacterModel);
			}
		}

		private void DestroyModelInstance()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			CachedSkinnedMeshRenderers.Clear();
			Object.Destroy((Object)(object)ModelInstance);
			ModelInstance = null;
			ModelSkinController = null;
			CharacterModel = null;
			((Graphic)icon).color = Color.clear;
			icon.texture = null;
			((TMP_Text)bodyNameText).text = null;
			((TMP_Text)modelNameText).text = null;
			reverseSkin = null;
		}

		private IEnumerator BuildModelInstance()
		{
			if (ModelInfo == null || Object.op_Implicit((Object)(object)ModelInstance))
			{
				yield break;
			}
			((Graphic)icon).color = Color.white;
			icon.texture = ModelInfo.characterBody.portraitIcon;
			((TMP_Text)bodyNameText).text = ModelInfo.localizedBodyName;
			((TMP_Text)modelNameText).text = ModelInfo.modelName;
			ModelInstance = Object.Instantiate<GameObject>(ModelInfo.modelPrefab, modelSpawnPosition.position, modelSpawnPosition.rotation);
			CharacterModel = ModelInstance.GetComponent<CharacterModel>();
			CharacterModel.constraintItemDisplaysScale = false;
			ModelSkinController = ModelInstance.GetComponent<ModelSkinController>();
			if (Object.op_Implicit((Object)(object)ModelSkinController) && ModelSkinController.skins.Length != 0)
			{
				yield return ModelSkinController.ApplySkinAsync(0, (AsyncReferenceHandleUnloadType)(-1));
				reverseSkin = new ReverseSkin(ModelInstance, ModelSkinController.skins[Mathf.Clamp(ModelSkinController.currentSkinIndex, 0, ModelSkinController.skins.Length - 1)]);
			}
			AimAnimator[] componentsInChildren = ModelInstance.GetComponentsInChildren<AimAnimator>();
			foreach (AimAnimator obj in componentsInChildren)
			{
				obj.inputBank = null;
				obj.directionComponent = null;
				((Behaviour)obj).enabled = false;
			}
			Animator[] componentsInChildren2 = ModelInstance.GetComponentsInChildren<Animator>();
			foreach (Animator obj2 in componentsInChildren2)
			{
				obj2.SetBool("isGrounded", true);
				obj2.SetFloat("aimPitchCycle", 0.5f);
				obj2.SetFloat("aimYawCycle", 0.5f);
				obj2.Play("Idle");
				obj2.Update(0f);
			}
			DitherModel[] componentsInChildren3 = ModelInstance.GetComponentsInChildren<DitherModel>();
			for (int i = 0; i < componentsInChildren3.Length; i++)
			{
				((Behaviour)componentsInChildren3[i]).enabled = false;
			}
			IKSimpleChain[] componentsInChildren4 = ModelInstance.GetComponentsInChildren<IKSimpleChain>();
			for (int i = 0; i < componentsInChildren4.Length; i++)
			{
				((Behaviour)componentsInChildren4[i]).enabled = false;
			}
			PrintController[] componentsInChildren5 = ModelInstance.GetComponentsInChildren<PrintController>();
			for (int i = 0; i < componentsInChildren5.Length; i++)
			{
				((Behaviour)componentsInChildren5[i]).enabled = false;
			}
			LightIntensityCurve[] componentsInChildren6 = ModelInstance.GetComponentsInChildren<LightIntensityCurve>();
			foreach (LightIntensityCurve val in componentsInChildren6)
			{
				if (!val.loop)
				{
					((Behaviour)val).enabled = false;
				}
			}
			AkEvent[] componentsInChildren7 = ModelInstance.GetComponentsInChildren<AkEvent>();
			for (int i = 0; i < componentsInChildren7.Length; i++)
			{
				((Behaviour)componentsInChildren7[i]).enabled = false;
			}
			ShakeEmitter[] componentsInChildren8 = ModelInstance.GetComponentsInChildren<ShakeEmitter>();
			for (int i = 0; i < componentsInChildren8.Length; i++)
			{
				((Behaviour)componentsInChildren8[i]).enabled = false;
			}
			Collider[] componentsInChildren9 = ModelInstance.GetComponentsInChildren<Collider>();
			for (int i = 0; i < componentsInChildren9.Length; i++)
			{
				componentsInChildren9[i].enabled = false;
			}
			InverseKinematics[] componentsInChildren10 = ModelInstance.GetComponentsInChildren<InverseKinematics>();
			for (int i = 0; i < componentsInChildren10.Length; i++)
			{
				((Behaviour)componentsInChildren10[i]).enabled = false;
			}
			MeshFilter[] componentsInChildren11 = ModelInstance.GetComponentsInChildren<MeshFilter>();
			foreach (MeshFilter val2 in componentsInChildren11)
			{
				MeshCollider obj3 = ((Component)val2).gameObject.AddComponent<MeshCollider>();
				obj3.convex = false;
				obj3.sharedMesh = val2.sharedMesh;
				((Component)val2).gameObject.layer = 11;
			}
			SkinnedMeshRenderer[] componentsInChildren12 = ModelInstance.GetComponentsInChildren<SkinnedMeshRenderer>();
			foreach (SkinnedMeshRenderer val3 in componentsInChildren12)
			{
				MeshCollider val4 = ((Component)val3).gameObject.AddComponent<MeshCollider>();
				val4.convex = false;
				val4.sharedMesh = new Mesh();
				((Component)val3).gameObject.layer = 11;
				CachedSkinnedMeshRenderers[val3] = val4;
			}
		}

		private void ConfigureSkinVariants()
		{
			skinsDropdown.ClearOptions();
			if (!Object.op_Implicit((Object)(object)ModelSkinController))
			{
				((Component)skinsDropdown).gameObject.SetActive(false);
				return;
			}
			skinsDropdown.AddOptions(((IEnumerable<SkinDef>)ModelSkinController.skins).Select((Func<SkinDef, OptionData>)delegate(SkinDef el)
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected O, but got Unknown
				string text = ((el.nameToken == null) ? ((Object)el).name : Language.GetString(el.nameToken));
				if (string.IsNullOrWhiteSpace(text))
				{
					text = "<No name>";
				}
				return new OptionData(text, el.icon);
			}).ToList());
			((Component)skinsDropdown).gameObject.SetActive(true);
		}

		public void SelectSkin(int index)
		{
			((MonoBehaviour)this).StartCoroutine(SelectSkinAsync(index));
		}

		public IEnumerator SelectSkinAsync(int index)
		{
			if (Object.op_Implicit((Object)(object)ModelSkinController))
			{
				ItemDisplayRuleSet oldIDRS = CharacterModel.itemDisplayRuleSet;
				reverseSkin?.Apply();
				yield return ModelSkinController.ApplySkinAsync(index, (AsyncReferenceHandleUnloadType)(-1));
				reverseSkin = new ReverseSkin(ModelInstance, ModelSkinController.skins[ModelSkinController.currentSkinIndex]);
				if ((Object)(object)oldIDRS != (Object)(object)CharacterModel.itemDisplayRuleSet)
				{
					ItemDisplayRuleSetController.Instance.DisableAll();
					ModelPicker.OnModelWillChange?.Invoke();
					ModelPicker.OnModelChanged?.Invoke(CharacterModel);
				}
			}
		}

		public void ToggleBodyOptions(bool enabled)
		{
			if (enabled)
			{
				dropdown.Options = allBodyOptions;
			}
			else
			{
				dropdown.Options = logbookBodyOptions;
			}
		}
	}
	public class ModelPrefabInfo
	{
		public GameObject modelPrefab;

		public string bodyName;

		public string localizedBodyName;

		public string modelName;

		public CharacterBody characterBody;
	}
	public class MouseEventConsumer : MonoBehaviour
	{
		private void OnMouseDrag()
		{
		}
	}
	[RequireComponent(typeof(TMP_InputField))]
	public class NavigateInputFieldOnTab : MonoBehaviour
	{
		private TMP_InputField inputField;

		public MoveDirection moveDirection;

		public Selectable staticTarget;

		private void Awake()
		{
			inputField = ((Component)this).GetComponent<TMP_InputField>();
		}

		private void Update()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected I4, but got Unknown
			if (!((Selectable)inputField).interactable || !inputField.isFocused)
			{
				return;
			}
			Navigation navigation = ((Selectable)inputField).navigation;
			if ((int)((Navigation)(ref navigation)).mode == 0 || !Input.GetKeyDown((KeyCode)9))
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)staticTarget))
			{
				staticTarget.Select();
				return;
			}
			Selectable val = null;
			MoveDirection val2 = moveDirection;
			switch ((int)val2)
			{
			case 0:
				val = ((Selectable)inputField).FindSelectableOnLeft();
				break;
			case 1:
				val = ((Selectable)inputField).FindSelectableOnUp();
				break;
			case 2:
				val = ((Selectable)inputField).FindSelectableOnRight();
				break;
			case 3:
				val = ((Selectable)inputField).FindSelectableOnDown();
				break;
			}
			if (Object.op_Implicit((Object)(object)val))
			{
				val.Select();
			}
		}
	}
	public class ParentedPrefabDisplayController : MonoBehaviour
	{
		private static readonly Regex placeholderRegex = new Regex("(?<!\\{)\\{((?<modificator>.??):)?(?<field>[^\\{\\}:]*?)(\\.(?<subfield>.*?))?(:(?<precision>.*?))?\\}(?!\\})", RegexOptions.Compiled);

		public TMP_Dropdown ruleTypeDropdown;

		public MultipleOptionsDropdown limbMaskDropdown;

		public Button selectPrefabButton;

		public TMP_Text prefabText;

		public TMP_Dropdown childNameDropdown;

		public SearchableDropdown childPathDropdown;

		[Space]
		public Vector3InputField localPosInput;

		public Vector3InputField localAnglesInput;

		public Vector3InputField localScaleInput;

		[Space]
		public Button copyToClipboardButton;

		public Button editCopyFormatButton;

		[Space]
		public GameObject editFormatContainer;

		public TMP_InputField customFormatInput;

		public TMP_Text formatPreviewText;

		public TMP_Dropdown formatDropdown;

		private CharacterModel characterModel;

		private CopyFormat _copyFormat;

		private const string blockFormat = "childName = {childName},\r\nlocalPos = {localPos:5},\r\nlocalAngles = {localAngles:5},\r\nlocalScale = {localScale:5}\r\n";

		private const string inlineFormat = "{childName}, {localPos:5}, {localAngles:5}, {localScale:5}";

		private const string forParsing = "{r:childName},{r:localPos.x:5},{r:localPos.y:5},{r:localPos.z:5},{r:localAngles.x:5},{r:localAngles.y:5},{r:localAngles.z:5},{r:localScale.x:5},{r:localScale.y:5},{r:localScale.z:5}";

		public EditableItemDisplayRule ItemDisplayRule { get; private set; }

		public static ParentedPrefabDisplayController Instance { get; private set; }

		public CopyFormat CopyFormat
		{
			get
			{
				return _copyFormat;
			}
			set
			{
				if (formatDropdown.value == (int)value)
				{
					SelectFormat((int)value);
				}
				else
				{
					formatDropdown.value = (int)value;
				}
			}
		}

		private void Awake()
		{
			Instance = this;
			Vector3InputField vector3InputField = localPosInput;
			vector3InputField.onValueChanged = (Vector3InputField.OnChangeEvent)Delegate.Combine(vector3InputField.onValueChanged, new Vector3InputField.OnChangeEvent(OnLocalPosChanged));
			Vector3InputField vector3InputField2 = localAnglesInput;
			vector3InputField2.onValueChanged = (Vector3InputField.OnChangeEvent)Delegate.Combine(vector3InputField2.onValueChanged, new Vector3InputField.OnChangeEvent(OnLocalAnglesChanged));
			Vector3InputField vector3InputField3 = localScaleInput;
			vector3InputField3.onValueChanged = (Vector3InputField.OnChangeEvent)Delegate.Combine(vector3InputField3.onValueChanged, new Vector3InputField.OnChangeEvent(OnLocalScaleChanged));
			ModelPicker.OnModelChanged += OnModelChanged;
			ModelPicker.OnModelWillChange += OnModelWillChange;
			DisplayRuleGroupEditingController.OnDisplayRuleGroupChanged = (DisplayRuleGroupEditingController.OnDisplayRuleGroupChangedHandler)Delegate.Combine(DisplayRuleGroupEditingController.OnDisplayRuleGroupChanged, new DisplayRuleGroupEditingController.OnDisplayRuleGroupChangedHandler(OnDisplayRuleGroupChanged));
			ruleTypeDropdown.AddOptions(((IEnumerable<string>)Enum.GetNames(typeof(ItemDisplayRuleType))).Select((Func<string, OptionData>)((string name) => new OptionData(name))).ToList());
			formatDropdown.AddOptions(((IEnumerable<string>)Enum.GetNames(typeof(CopyFormat))).Select((Func<string, OptionData>)((string name) => new OptionData(name))).ToList());
			string[] names = Enum.GetNames(typeof(LimbFlags));
			IList values = Enum.GetValues(typeof(LimbFlags));
			List<MultipleOptionsDropdown.OptionData> list = new List<MultipleOptionsDropdown.OptionData>();
			for (int num = 0; num < names.Length; num++)
			{
				int num2 = (int)values[num];
				if (Utils.IsPowerOfTwo(num2))
				{
					list.Add(new MultipleOptionsDropdown.OptionData(names[num], null, num2));
				}
			}
			limbMaskDropdown.AddOptions(list);
		}

		private void OnDestroy()
		{
			ModelPicker.OnModelChanged -= OnModelChanged;
			ModelPicker.OnModelWillChange -= OnModelWillChange;
			DisplayRuleGroupEditingController.OnDisplayRuleGroupChanged = (DisplayRuleGroupEditingController.OnDisplayRuleGroupChangedHandler)Delegate.Remove(DisplayRuleGroupEditingController.OnDisplayRuleGroupChanged, new DisplayRuleGroupEditingController.OnDisplayRuleGroupChangedHandler(OnDisplayRuleGroupChanged));
			Instance = null;
		}

		private void OnModelWillChange()
		{
			ClearValues();
			childNameDropdown.ClearOptions();
			childPathDropdown.ClearOptions();
		}

		private void OnModelChanged(CharacterModel characterModel)
		{
			this.characterModel = characterModel;
			if (Object.op_Implicit((Object)(object)characterModel) && Object.op_Implicit((Object)(object)characterModel.childLocator))
			{
				childNameDropdown.options.AddRange(((IEnumerable<NameTransformPair>)characterModel.childLocator.transformPairs).Select((Func<NameTransformPair, OptionData>)((NameTransformPair el) => new OptionData(el.name))).ToList());
				BuildChildPathDropdownOptions(ModelPicker.Instance.ModelInfo.modelPrefab.transform);
			}
		}

		private void BuildChildPathDropdownOptions(Transform parent, string parentPath = null)
		{
			int childCount = parent.childCount;
			for (int i = 0; i < childCount; i++)
			{
				Transform child = parent.GetChild(i);
				string text = ((parentPath == null) ? ((Object)child).name : (parentPath + "/" + ((Object)child).name));
				childPathDropdown.Options.Add(new SearchableDropdown.OptionData(text, text));
				BuildChildPathDropdownOptions(child, text);
			}
		}

		private void OnDisplayRuleGroupChanged(EditableDisplayRuleGroup keyAssetRuleGroup)
		{
			SetItemDisplayRule(null);
		}

		private void Update()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Invalid comparison between Unknown and I4
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Invalid comparison between Unknown and I4
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			bool flag = ItemDisplayRule != null;
			bool flag2 = Object.op_Implicit((Object)(object)ItemDisplayRule?.instance);
			((Selectable)ruleTypeDropdown).interactable = flag;
			MultipleOptionsDropdown multipleOptionsDropdown = limbMaskDropdown;
			EditableItemDisplayRule itemDisplayRule = ItemDisplayRule;
			((Selectable)multipleOptionsDropdown).interactable = itemDisplayRule != null && (int)itemDisplayRule.ruleType == 1;
			EditableItemDisplayRule itemDisplayRule2 = ItemDisplayRule;
			bool interactable = itemDisplayRule2 != null && (int)itemDisplayRule2.ruleType == 0;
			((Selectable)selectPrefabButton).interactable = interactable;
			((Selectable)childNameDropdown).interactable = interactable;
			((Selectable)childPathDropdown).interactable = interactable;
			localPosInput.interactable = flag2;
			localAnglesInput.interactable = flag2;
			localScaleInput.interactable = flag2;
			((Selectable)copyToClipboardButton).interactable = flag;
			((Selectable)editCopyFormatButton).interactable = flag;
			if (!flag)
			{
				editFormatContainer.SetActive(false);
			}
			if (flag2)
			{
				localPosInput.SetValueWithoutNotify(ItemDisplayRule.instance.transform.localPosition);
				localAnglesInput.SetValueWithoutNotify(ItemDisplayRule.instance.transform.localEulerAngles);
				localScaleInput.SetValueWithoutNotify(ItemDisplayRule.instance.transform.localScale);
				ItemDisplayRule.localPos = localPosInput.CurrentValue;
				ItemDisplayRule.localAngles = localAnglesInput.CurrentValue;
				ItemDisplayRule.localScale = localScaleInput.CurrentValue;
			}
		}

		private void ClearValues()
		{
			prefabText.text = "No prefab";
			ruleTypeDropdown.SetValueWithoutNotify(-1);
			ruleTypeDropdown.RefreshShownValue();
			limbMaskDropdown.SetValueWithoutNotify(0);
			limbMaskDropdown.RefreshShownValue();
			childNameDropdown.SetValueWithoutNotify(-1);
			childNameDropdown.RefreshShownValue();
			localPosInput.ClearValues();
			localAnglesInput.ClearValues();
			localScaleInput.ClearValues();
		}

		public void SetItemDisplayRule(EditableItemDisplayRule itemDisplayRule)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected I4, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected I4, but got Unknown
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			if (ItemDisplayRule == itemDisplayRule)
			{
				return;
			}
			ClearValues();
			ItemDisplayRule = itemDisplayRule;
			EditorAxisController.Instance.SetSelectedObject(Object.op_Implicit((Object)(object)ItemDisplayRule?.instance) ? ItemDisplayRule.instance.transform : null);
			if (ItemDisplayRule == null)
			{
				return;
			}
			ruleTypeDropdown.SetValueWithoutNotify((int)itemDisplayRule.ruleType);
			ruleTypeDropdown.RefreshShownValue();
			limbMaskDropdown.SetValueWithoutNotify((int)itemDisplayRule.limbMask);
			limbMaskDropdown.RefreshShownValue();
			prefabText.text = (Object.op_Implicit((Object)(object)itemDisplayRule.followerPrefab) ? ((Object)itemDisplayRule.followerPrefab).name : "No prefab");
			GameObject instance = itemDisplayRule.instance;
			Transform displayTransform = ((instance != null) ? instance.transform : null);
			if (Object.op_Implicit((Object)(object)displayTransform))
			{
				string childName = ((IEnumerable<NameTransformPair>)characterModel.childLocator.transformPairs).FirstOrDefault((Func<NameTransformPair, bool>)((NameTransformPair el) => (Object)(object)el.transform == (Object)(object)displayTransform.parent)).name;
				childNameDropdown.SetValueWithoutNotify(childNameDropdown.options.FindIndex((OptionData el) => el.text == childName));
				childNameDropdown.RefreshShownValue();
				localPosInput.SetValueWithoutNotify(displayTransform.localPosition, forceUpdate: true);
				localAnglesInput.SetValueWithoutNotify(displayTransform.localEulerAngles, forceUpdate: true);
				localScaleInput.SetValueWithoutNotify(displayTransform.localScale, forceUpdate: true);
			}
			else
			{
				childNameDropdown.SetValueWithoutNotify(childNameDropdown.options.FindIndex((OptionData el) => el.text == ItemDisplayRule.childName));
				childNameDropdown.RefreshShownValue();
				localPosInput.SetValueWithoutNotify(ItemDisplayRule.localPos, forceUpdate: true);
				localAnglesInput.SetValueWithoutNotify(ItemDisplayRule.localAngles, forceUpdate: true);
				localScaleInput.SetValueWithoutNotify(ItemDisplayRule.localScale, forceUpdate: true);
			}
		}

		public void SelectRuleType(int index)
		{
			//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_000e: 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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Invalid comparison between Unknown and I4
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			ItemDisplayRule.ruleType = (ItemDisplayRuleType)index;
			ItemDisplayRuleType val = (ItemDisplayRuleType)index;
			if ((int)val != 0)
			{
				if ((int)val == 1)
				{
					Object.Destroy((Object)(object)ItemDisplayRule.instance);
					ItemDisplayRule.instance = null;
					characterModel.limbFlagSet.AddFlags(ItemDisplayRule.limbMask);
				}
			}
			else
			{
				characterModel.limbFlagSet.RemoveFlags(ItemDisplayRule.limbMask);
				ItemDisplayRule.TrySpawnInstance(characterModel);
			}
			characterModel.materialsDirty = true;
			EditorAxisController.Instance.SetSelectedObject(Object.op_Implicit((Object)(object)ItemDisplayRule?.instance) ? ItemDisplayRule.instance.transform : null);
		}

		public void SelectLimbMask(int value)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			characterModel.limbFlagSet.RemoveFlags(ItemDisplayRule.limbMask);
			ItemDisplayRule.limbMask = (LimbFlags)value;
			characterModel.limbFlagSet.AddFlags(ItemDisplayRule.limbMask);
			characterModel.materialsDirty = true;
		}

		public void SelectPrefab()
		{
			ItemDisplayRuleSetController.Instance.FillPrefabReference(ItemDisplayRule, refreshBundles: true);
			AssetReferenceGameObject followerPrefabAddress = ItemDisplayRule.followerPrefabAddress;
			DialogController.ShowPrefabPicker((followerPrefabAddress != null) ? ((AssetReference)followerPrefabAddress).AssetGUID : null, ItemDisplayRule.assetBundle, ItemDisplayRule.assetPath, delegate(GameObject prefab, AssetReferenceGameObject reference, string assetBundle, string path)
			{
				if (Object.op_Implicit((Object)(object)ItemDisplayRule.instance))
				{
					Object.Destroy((Object)(object)ItemDisplayRule.instance);
					ItemDisplayRule.instance = null;
				}
				ItemDisplayRule.followerPrefab = prefab;
				ItemDisplayRule.followerPrefabAddress = reference;
				ItemDisplayRule.assetBundle = assetBundle;
				ItemDisplayRule.assetPath = path;
				ItemDisplayRule.referenceDiscovered = true;
				ItemDisplayRule.TrySpawnInstance(characterModel);
				prefabText.text = ((Object)ItemDisplayRule.followerPrefab).name;
				EditorAxisController.Instance.SetSelectedObject(Object.op_Implicit((Object)(object)ItemDisplayRule?.instance) ? ItemDisplayRule.instance.transform : null);
			});
		}

		public void OnLocalPosChanged(Vector3 value)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)ItemDisplayRule.instance))
			{
				ItemDisplayRule.instance.transform.localPosition = value;
			}
		}

		public void OnLocalAnglesChanged(Vector3 value)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)ItemDisplayRule.instance))
			{
				ItemDisplayRule.instance.transform.localEulerAngles = value;
			}
		}

		public void OnLocalScaleChanged(Vector3 value)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)ItemDisplayRule.instance))
			{
				ItemDisplayRule.instance.transform.localScale = value;
			}
		}

		public void SelectChild(int index)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			NameTransformPair val = characterModel.childLocator.transformPairs[index];
			Transform transform = val.transform;
			ItemDisplayRule.childName = val.name;
			ItemDisplayRule.TrySpawnInstance(characterModel);
			if (Object.op_Implicit((Object)(object)ItemDisplayRule.followerPrefab))
			{
				prefabText.text = ((Object)ItemDisplayRule.followerPrefab).name;
			}
			if (Object.op_Implicit((Object)(object)ItemDisplayRule.instance))
			{
				ItemDisplayRule.instance.transform.SetParent(transform, false);
				EditorAxisController.Instance.SetSelectedObject(ItemDisplayRule.instance.transform);
			}
		}

		public void AddNewChild(object childPathObj)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			string text = childPathObj as string;
			CharacterModel val = ModelPicker.Instance.CharacterModel;
			string text2 = StringHelpers.ChildNameFromPath(text);
			ChildLocator childLocator = val.childLocator;
			int num = childLocator.FindChildIndex(text2);
			if (num < 0)
			{
				num = childLocator.transformPairs.Length;
				Transform transform = ((Component)val).transform.Find(text);
				ref NameTransformPair[] transformPairs = ref childLocator.transformPairs;
				NameTransformPair val2 = new NameTransformPair
				{
					name = text2,
					transform = transform
				};
				ArrayUtils.ArrayAppend<NameTransformPair>(ref transformPairs, ref val2);
				childNameDropdown.options.Add(new OptionData(text2));
			}
			childNameDropdown.value = num;
		}

		public void SelectFormat(int format)
		{
			_copyFormat = (CopyFormat)format;
			((Component)customFormatInput).gameObject.SetActive(CopyFormat == CopyFormat.Custom);
			((Component)formatPreviewText.transform.parent.parent).gameObject.SetActive(CopyFormat != CopyFormat.Custom);
			formatPreviewText.text = GetText();
		}

		public void CopyValuesToClipboard()
		{
			try
			{
				ItemDisplayRuleSetController.Instance.FillPrefabReference(ItemDisplayRule, refreshBundles: true);
				string text = GetText();
				GUIUtility.systemCopyBuffer = ReplacePlaceHolders(text);
			}
			catch (Exception ex)
			{
				DialogController.ShowError(ex.Message);
			}
		}

		public void ToogleEditFormatContainerVisibility()
		{
			editFormatContainer.SetActive(!editFormatContainer.activeSelf);
		}

		private string ReplacePlaceHolders(string text)
		{
			MatchCollection matchCollection = placeholderRegex.Matches(text);
			if (matchCollection.Count == 0)
			{
				return text;
			}
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			for (int i = 0; i < matchCollection.Count; i++)
			{
				Match match = matchCollection[i];
				stringBuilder.Append(text.Substring(num, match.Index - num).Replace("{{", "{").Replace("}}", "}"));
				num = match.Index + match.Length;
				stringBuilder.Append(ParsePlaceHolder(match));
			}
			if (matchCollection.Count == 0)
			{
				return text;
			}
			if (num != text.Length)
			{
				stringBuilder.Append(text.Substring(num, text.Length - num).Replace("{{", "{").Replace("}}", "}"));
			}
			return stringBuilder.ToString();
		}

		private string ParsePlaceHolder(Match match)
		{
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			string modificator = match.Groups["modificator"].Value?.ToLower();
			string value = match.Groups["field"].Value;
			string value2 = match.Groups["subfield"].Value;
			int result = 5;
			if (match.Groups["precision"].Success && !int.TryParse(match.Groups["precision"].Value, out result))
			{
				throw new ArgumentException("Failed to parse placeholder " + match.Value);
			}
			switch (value)
			{
			case "childName":
				return TemplateHelpers.StringText(ItemDisplayRule.childName, modificator);
			case "localPos":
				return TemplateHelpers.Vector3Text(ItemDisplayRule.localPos, result, modificator, value2);
			case "localAngles":
				return TemplateHelpers.Vector3Text(ItemDisplayRule.localAngles, result, modificator, value2);
			case "localScale":
				return TemplateHelpers.Vector3Text(ItemDisplayRule.localScale, result, modificator, value2);
			case "modelName":
				return TemplateHelpers.StringText(ModelPicker.Instance.ModelInfo.modelName, modificator);
			case "bodyName":
				return TemplateHelpers.StringText(ModelPicker.Instance.ModelInfo.bodyName, modificator);
			case "itemName":
				return TemplateHelpers.StringText(DisplayRuleGroupEditingController.Instance.DisplayRuleGroup.KeyAsset.name, modificator);
			case "objectName":
			{
				GameObject followerPrefab = ItemDisplayRule.followerPrefab;
				return TemplateHelpers.StringText((followerPrefab != null) ? ((Object)followerPrefab).name : null, modificator);
			}
			case "ruleType":
				return TemplateHelpers.EnumValue<ItemDisplayRuleType>(ItemDisplayRule.ruleType, modificator);
			case "limbMask":
				return TemplateHelpers.EnumFlagsValue<LimbFlags>(ItemDisplayRule.limbMask, modificator);
			case "guid":
			{
				AssetReferenceGameObject followerPrefabAddress = ItemDisplayRule.followerPrefabAddress;
				return TemplateHelpers.StringText((followerPrefabAddress != null) ? ((AssetReference)followerPrefabAddress).AssetGUID : null, modificator);
			}
			case "assetBundle":
				return TemplateHelpers.StringText(ItemDisplayRule.assetBundle, modificator);
			case "assetPath":
				return TemplateHelpers.StringText(ItemDisplayRule.assetPath, modificator);
			case "skinName":
			{
				ModelSkinController modelSkinController = ModelPicker.Instance.ModelSkinController;
				SkinDef safe = ArrayUtils.GetSafe<SkinDef>(modelSkinController.skins, modelSkinController.currentSkinIndex);
				return TemplateHelpers.StringText(Object.op_Implicit((Object)(object)safe) ? ((Object)safe).name : "", modificator);
			}
			default:
				throw new ArgumentException("Failed to parse placeholder " + match.Value);
			}
		}

		private string GetText()
		{
			return CopyFormat switch
			{
				CopyFormat.Custom => customFormatInput.text, 
				CopyFormat.Block => "childName = {childName},\r\nlocalPos = {localPos:5},\r\nlocalAngles = {localAngles:5},\r\nlocalScale = {localScale:5}\r\n", 
				CopyFormat.Inline => "{childName}, {localPos:5}, {localAngles:5}, {localScale:5}", 
				CopyFormat.ForParsing => "{r:childName},{r:localPos.x:5},{r:localPos.y:5},{r:localPos.z:5},{r:localAngles.x:5},{r:localAngles.y:5},{r:localAngles.z:5},{r:localScale.x:5},{r:localScale.y:5},{r:localScale.z:5}", 
				_ => throw new IndexOutOfRangeException(), 
			};
		}
	}
	public class ReverseSkin
	{
		private readonly List<RendererInfo> baseRendererInfos = new List<RendererInfo>();

		private readonly List<GameObjectActivationTemplate> gameObjectActivationTemplates = new List<GameObjectActivationTemplate>();

		private readonly List<MeshReplacementTemplate> meshReplacementTemplates = new List<MeshReplacementTemplate>();

		private readonly GameObject modelObject;

		public ReverseSkin(GameObject modelObject, SkinDef skinDef)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: 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)
			this.modelObject = modelObject;
			IEnumerator enumerator = skinDef.BakeAsync();
			while (enumerator.MoveNext())
			{
			}
			RuntimeSkin runtimeSkin = skinDef.runtimeSkin;
			baseRendererInfos.AddRange(modelObject.GetComponent<CharacterModel>().baseRendererInfos);
			Enumerator<GameObjectActivationTemplate> enumerator2 = runtimeSkin.gameObjectActivationTemplates.GetEnumerator();
			try
			{
				while (enumerator2.MoveNext())
				{
					GameObjectActivationTemplate current = enumerator2.Current;
					gameObjectActivationTemplates.Add(new GameObjectActivationTemplate
					{
						transformPath = current.transformPath,
						shouldActivate = !current.shouldActivate
					});
				}
			}
			finally
			{
				((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
			}
			Enumerator<MeshReplacementTemplate> enumerator3 = runtimeSkin.meshReplacementTemplates.GetEnumerator();
			try
			{
				while (enumerator3.MoveNext())
				{
					MeshReplacementTemplate current2 = enumerator3.Current;
					Renderer component = ((Component)modelObject.transform.Find(current2.transformPath)).GetComponent<Renderer>();
					Mesh directRef = null;
					if (!(component is MeshRenderer))
					{
						SkinnedMeshRenderer val = (SkinnedMeshRenderer)(object)((component is SkinnedMeshRenderer) ? component : null);
						if (val != null)
						{
							directRef = val.sharedMesh;
						}
					}
					else
					{
						directRef = ((Component)component).GetComponent<MeshFilter>().sharedMesh;
					}
					meshReplacementTemplates.Add(new MeshReplacementTemplate
					{
						transformPath = current2.transformPath,
						meshReference = new AssetOrDirectReference<Mesh>
						{
							directRef = directRef
						}
					});
				}
			}
			finally
			{
				((IDisposable)enumerator3/*cast due to .constrained prefix*/).Dispose();
			}
		}

		public void Apply()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)modelObject))
			{
				return;
			}
			Transform transform = modelObject.transform;
			modelObject.GetComponent<CharacterModel>().baseRendererInfos = baseRendererInfos.ToArray();
			foreach (GameObjectActivationTemplate gameObjectActivationTemplate in gameObjectActivationTemplates)
			{
				((Component)transform.Find(gameObjectActivationTemplate.transformPath)).gameObject.SetActive(gameObjectActivationTemplate.shouldActivate);
			}
			foreach (MeshReplacementTemplate meshReplacementTemplate in meshReplacementTemplates)
			{
				Renderer component = ((Component)transform.Find(meshReplacementTemplate.transformPath)).GetComponent<Renderer>();
				if (!(component is MeshRenderer))
				{
					SkinnedMeshRenderer val = (SkinnedMeshRenderer)(object)((component is SkinnedMeshRenderer) ? component : null);
					if (val != null)
					{
						val.sharedMesh = meshReplacementTemplate.meshReference.directRef;
					}
				}
				else
				{
					((Component)component).GetComponent<MeshFilter>().sharedMesh = meshReplacementTemplate.meshReference.directRef;
				}
			}
		}
	}
	public class RotateWithObject : MonoBehaviour
	{
		public Transform objectTransform;

		private void LateUpdate()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)objectTransform))
			{
				((Component)this).transform.rotation = objectTransform.rotation;
			}
		}
	}
	[AddComponentMenu("UI/Searchable Dropdown", 35)]
	[RequireComponent(typeof(RectTransform))]
	public class SearchableDropdown : TMP_InputField, IEventSystemHandler, ICancelHandler
	{
		public class OptionData
		{
			public object Value { get; set; }

			public string Text { get; set; }

			public Sprite Image { get; set; }

			public OptionData()
			{
			}

			public OptionData(object value, string text)
			{
				Value = value;
				Text = text;
			}

			public OptionData(object value, Sprite image)
			{
				Value = value;
				Image = image;
			}

			public OptionData(object value, string text, Sprite image)
			{
				Value = value;
				Text = text;
				Image = image;
			}
		}

		[Serializable]
		public class DropdownEvent : UnityEvent<object>
		{
		}

		[SerializeField]
		private RectTransform m_Template;

		[Space]
		[SerializeField]
		private TMP_Text m_ItemText;

		[SerializeField]
		private Image m_ItemImage;

		[SerializeField]
		private TMP_Text m_SelectText;

		[Space]
		private GameObject m_Dropdown;

		private GameObject m_Blocker;

		private List<DropdownItem> m_Items = new List<DropdownItem>();

		private FloatTweenRunner m_AlphaTweenRunner;

		private bool validTemplate;

		private Canvas rootCanvas;

		private Vector2 initialContentSizeDelta;

		private Vector2 initialDropdownSizeDelta;

		[SerializeField]
		private DropdownEvent m_OnItemSelected;

		public RectTransform template
		{
			get
			{
				return m_Template;
			}
			set
			{
				m_Template = value;
			}
		}

		public TMP_Text itemText
		{
			get
			{
				return m_ItemText;
			}
			set
			{
				m_ItemText = value;
			}
		}

		public Image itemImage
		{
			get
			{
				return m_ItemImage;
			}
			set
			{
				m_ItemImage = value;
			}
		}

		public List<OptionData> Options { get; set; } = new List<OptionData>();

		public DropdownEvent OnItemSelected
		{
			get
			{
				return m_OnItemSelected;
			}
			set
			{
				m_OnItemSelected = value;
			}
		}

		public bool IsExpanded => (Object)(object)m_Dropdown != (Object)null;

		protected SearchableDropdown()
		{
		}

		protected override void Awake()
		{
			((Selectable)this).Awake();
			m_AlphaTweenRunner = new FloatTweenRunner();
			m_AlphaTweenRunner.Init((MonoBehaviour)(object)this);
			if (Object.op_Implicit((Object)(object)m_Template))
			{
				((Component)m_Template).gameObject.SetActive(false);
				((UnityEvent<string>)(object)((TMP_InputField)this).onValueChanged).AddListener((UnityAction<string>)ApplyOptionsFilter);
			}
		}

		protected override void Start()
		{
			((Component)((TMP_InputField)this).textViewport).gameObject.SetActive(false);
			((UIBehaviour)this).Start();
		}

		protected override void OnDisable()
		{
			((TMP_InputField)this).OnDisable();
			ImmediateDestroyDropdownList();
			if (!Object.op_Implicit((Object)(object)m_Blocker))
			{
				DestroyBlocker(m_Blocker);
			}
			m_Blocker = null;
		}

		public void AddOptions(List<OptionData> options)
		{
			Options.AddRange(options);
		}

		public void AddOptions(Dictionary<object, string> options)
		{
			foreach (KeyValuePair<object, string> option in options)
			{
				Options.Add(new OptionData(option.Key, option.Value));
			}
		}

		public void AddOptions(Dictionary<object, Sprite> options)
		{
			foreach (KeyValuePair<object, Sprite> option in options)
			{
				Options.Add(new OptionData(option.Key, option.Value));
			}
		}

		public void ClearOptions()
		{
			Options.Clear();
		}

		private void SetupTemplate()
		{
			validTemplate = false;
			if (!Object.op_Implicit((Object)(object)m_Template))
			{
				Debug.LogError((object)"The dropdown template is not assigned. The template needs to be assigned and must have a child GameObject with a Toggle component serving as the item.", (Object)(object)this);
				return;
			}
			GameObject gameObject = ((Component)m_Template).gameObject;
			gameObject.SetActive(true);
			validTemplate = true;
			Button componentInChildren = gameObject.GetComponentInChildren<Button>();
			if (!Object.op_Implicit((Object)(object)componentInChildren) || (Object)(object)((Component)componentInChildren).transform == (Object)(object)template)
			{
				validTemplate = false;
				Debug.LogError((object)"The dropdown template is not valid. The template must have a child GameObject with a Button component serving as the item.", (Object)(object)template);
			}
			else if (!(((Component)componentInChildren).transform.parent is RectTransform))
			{
				validTemplate = false;
				Debug.LogError((object)"The dropdown template is not valid. The child GameObject with a Button component (the item) must have a RectTransform on its parent.", (Object)(object)template);
			}
			else if ((Object)(object)itemText != (Object)null && !itemText.transform.IsChildOf(((Component)componentInChildren).transform))
			{
				validTemplate = false;
				Debug.LogError((object)"The dropdown template is not valid. The Item Text must be on the item GameObject or children of it.", (Object)(object)template);
			}
			else if ((Object)(object)itemImage != (Object)null && !((Component)itemImage).transform.IsChildOf(((Component)componentInChildren).transform))
			{
				validTemplate = false;
				Debug.LogError((object)"The dropdown template is not valid. The Item Image must be on the item GameObject or children of it.", (Object)(object)template);
			}
			if (!validTemplate)
			{
				gameObject.SetActive(false);
				return;
			}
			Canvas orAddComponent = GetOrAddComponent<Canvas>(gameObject);
			orAddComponent.overrideSorting = true;
			orAddComponent.sortingOrder = 30000;
			GetOrAddComponent<GraphicRaycaster>(gameObject);
			GetOrAddComponent<CanvasGroup>(gameObject);
			gameObject.SetActive(false);
			Canvas orAddComponent2 = GetOrAddComponent<Canvas>(((Component)((TMP_InputField)this).textViewport).gameObject);
			orAddComponent2.overrideSorting = true;
			orAddComponent2.sortingOrder = 30000;
			GetOrAddComponent<GraphicRaycaster>(((Component)((TMP_InputField)this).textViewport).gameObject);
			GetOrAddComponent<CanvasGroup>(((Component)((TMP_InputField)this).textViewport).gameObject);
			validTemplate = true;
		}

		private static T GetOrAddComponent<T>(GameObject go) where T : Component
		{
			T val = go.GetComponent<T>();
			if (!Object.op_Implicit((Object)(object)val))
			{
				val = go.AddComponent<T>();
			}
			return val;
		}

		public override void OnPointerClick(PointerEventData eventData)
		{
			Show();
			((TMP_InputField)this).OnPointerClick(eventData);
		}

		public virtual void OnCancel(BaseEventData eventData)
		{
			Hide();
		}

		public void Show()
		{
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Expected O, but got Unknown
			if (!((UIBehaviour)this).IsActive() || !((Selectable)this).IsInteractable() || Object.op_Implicit((Object)(object)m_Dropdown))
			{
				return;
			}
			Canvas[] componentsInParent = ((Component)this).gameObject.GetComponentsInParent<Canvas>(false);
			if (componentsInParent.Length == 0)
			{
				return;
			}
			rootCanvas = componentsInParent[^1];
			for (int i = 0; i < componentsInParent.Length; i++)
			{
				if (componentsInParent[i].isRootCanvas)
				{
					rootCanvas = componentsInParent[i];
					break;
				}
			}
			componentsInParent = null;
			if (!validTemplate)
			{
				SetupTemplate();
				if (!validTemplate)
				{
					return;
				}
			}
			((Component)m_Template).gameObject.SetActive(true);
			((Component)m_Template).GetComponent<Canvas>().sortingLayerID = rootCanvas.sortingLayerID;
			((Component)((TMP_InputField)this).textViewport).gameObject.SetActive(true);
			Canvas component = ((Component)((TMP_InputField)this).textViewport).GetComponent<Canvas>();
			component.overrideSorting = true;
			component.sortingOrder = 30000;
			component.sortingLayerID = rootCanvas.sortingLayerID;
			if (Object.op_Implicit((Object)(object)m_SelectText))
			{
				((Component)m_SelectText).gameObject.SetActive(false);
			}
			m_Dropdown = CreateDropdownList(((Component)m_Template).gameObject);
			((Object)m_Dropdown).name = "Dropdown List";
			m_Dropdown.SetActive(true);
			Transform transform = m_Dropdown.transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			((Transform)val).SetParent(((Component)m_Template).transform.parent, false);
			DropdownItem componentInChildren = m_Dropdown.GetComponentInChildren<DropdownItem>();
			Transform transform2 = ((Component)((Transform)componentInChildren.rectTransform).parent).gameObject.transform;
			RectTransform val2 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
			initialContentSizeDelta = val2.sizeDelta;
			initialDropdownSizeDelta = val.sizeDelta;
			((Component)componentInChildren.rectTransform).gameObject.SetActive(true);
			m_Items.Clear();
			for (int j = 0; j < Options.Count; j++)
			{
				DropdownItem item = AddItem(Options[j], componentInChildren, m_Items);
				if (Object.op_Implicit((Object)(object)item.button))
				{
					((UnityEvent)item.button.onClick).AddListener((UnityAction)delegate
					{
						OnSelectItem(item.Value);
					});
				}
			}
			RecalculateDropdownBounds();
			AlphaFadeList(0.15f, 0f, 1f);
			((Component)m_Template).gameObject.SetActive(false);
			((Component)componentInChildren).gameObject.SetActive(false);
			m_Blocker = CreateBlocker(rootCanvas);
		}

		private void RecalculateDropdownBounds()
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: 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_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)m_Dropdown))
			{
				return;
			}
			Transform transform = m_Dropdown.transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			DropdownItem componentInChildren = m_Dropdown.GetComponentInChildren<DropdownItem>(true);
			Transform transform2 = ((Component)((Transform)componentInChildren.rectTransform).parent).gameObject.transform;
			RectTransform val2 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
			DropdownItem[] array = m_Items.Where((DropdownItem el) => ((Component)el).gameObject.activeSelf).ToArray();
			val2.sizeDelta = initialContentSizeDelta;
			val.sizeDelta = initialDropdownSizeDelta;
			Rect rect = val2.rect;
			Rect rect2 = componentInChildren.rectTransform.rect;
			Vector2 val3 = ((Rect)(ref rect2)).min - ((Rect)(ref rect)).min + Vector2.op_Implicit(((Transform)componentInChildren.rectTransform).localPosition);
			Vector2 val4 = ((Rect)(ref rect2)).max - ((Rect)(ref rect)).max + Vector2.op_Implicit(((Transform)componentInChildren.rectTransform).localPosition);
			Vector2 size = ((Rect)(ref rect2)).size;
			Vector2 sizeDelta = val2.sizeDelta;
			sizeDelta.y = size.y * (float)array.Length + val3.y - val4.y;
			val2.sizeDelta = sizeDelta;
			Rect rect3 = val.rect;
			double num = ((Rect)(ref rect3)).height;
			rect3 = val2.rect;
			double num2 = ((Rect)(ref rect3)).height;
			float num3 = (float)(num - num2);
			if ((double)num3 > 0.0)
			{
				val.sizeDelta = new Vector2(val.sizeDelta.x, val.sizeDelta.y - num3);
			}
			Vector3[] array2 = (Vector3[])(object)new Vector3[4];
			val.GetWorldCorners(array2);
			Transform transform3 = ((Component)rootCanvas).transform;
			RectTransform val5 = (RectTransform)(object)((transform3 is RectTransform) ? transform3 : null);
			Rect rect4 = val5.rect;
			for (int num4 = 0; num4 < 2; num4++)
			{
				bool flag = false;
				for (int num5 = 0; num5 < 4; num5++)
				{
					Vector3 val6 = ((Transform)val5).InverseTransformPoint(array2[num5]);
					double num6 = ((Vector3)(ref val6))[num4];
					Vector2 val7 = ((Rect)(ref rect4)).min;
					double num7 = ((Vector2)(ref val7))[num4];
					if (num6 < num7)
					{
						double num8 = ((Vector3)(ref val6))[num4];
						val7 = ((Rect)(ref rect4)).min;
						double num9 = ((Vector2)(ref val7))[num4];
						if (!Mathf.Approximately((float)num8, (float)num9))
						{
							goto IL_0278;
						}
					}
					double num10 = ((Vector3)(ref val6))[num4];
					val7 = ((Rect)(ref rect4)).max;
					double num11 = ((Vector2)(ref val7))[num4];
					if (!(num10 > num11))
					{
						continue;
					}
					double num12 = ((Vector3)(ref val6))[num4];
					val7 = ((Rect)(ref rect4)).max;
					double num13 = ((Vector2)(ref val7))[num4];
					if (Mathf.Approximately((float)num12, (float)num13))
					{
						continue;
					}
					goto IL_0278;
					IL_0278:
					flag = true;
					break;
				}
				if (flag)
				{
					RectTransformUtility.FlipLayoutOnAxis(val, num4, false, false);
				}
			}
			for (int num14 = 0; num14 < array.Length; num14++)
			{
				RectTransform rectTransform = array[num14].rectTransform;
				rectTransform.anchorMin = new Vector2(rectTransform.anchorMin.x, 0f);
				rectTransform.anchorMax = new Vector2(rectTransform.anchorMax.x, 0f);
				rectTransform.anchoredPosition = new Vector2(rectTransform.anchoredPosition.x, (float)((double)val3.y + (double)size.y * (double)(array.Length - 1 - num14) + (double)size.y * (double)rectTransform.pivot.y));
				rectTransform.sizeDelta = new Vector2(rectTransform.sizeDelta.x, size.y);
			}
		}

		protected virtual GameObject CreateBlocker(Canvas rootCanvas)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			//IL_00ad: Expected O, but got Unknown
			GameObject val = new GameObject("Blocker");
			RectTransform obj = val.AddComponent<RectTransform>();
			((Transform)obj).SetParent(((Component)rootCanvas).transform, false);
			obj.anchorMin = Vector2.op_Implicit(Vector3.zero);
			obj.anchorMax = Vector2.op_Implicit(Vector3.one);
			obj.sizeDelta = Vector2.zero;
			Canvas obj2 = val.AddComponent<Canvas>();
			obj2.overrideSorting = true;
			Canvas component = m_Dropdown.GetComponent<Canvas>();
			obj2.sortingLayerID = component.sortingLayerID;
			obj2.sortingOrder = component.sortingOrder - 1;
			val.AddComponent<GraphicRaycaster>();
			((Graphic)val.AddComponent<Image>()).color = Color.clear;
			((UnityEvent)val.AddComponent<Button>().onClick).AddListener(new UnityAction(Hide));
			return val;
		}

		protected virtual GameObject CreateDropdownList(GameObject template)
		{
			return Object.Instantiate<GameObject>(template);
		}

		protected virtual void DestroyBlocker(GameObject blocker)
		{
			Object.Destroy((Object)(object)blocker);
		}

		protected virtual void DestroyDropdownList(GameObject dropdownList)
		{
			Object.Destroy((Object)(object)dropdownList);
		}

		protected virtual DropdownItem CreateItem(DropdownItem itemTemplate)
		{
			return Object.Instantiate<DropdownItem>(itemTemplate);
		}

		protected virtual void DestroyItem(DropdownItem item)
		{
		}

		private DropdownItem AddItem(OptionData data, DropdownItem itemTemplate, List<DropdownItem> items)
		{
			DropdownItem dropdownItem = CreateItem(itemTemplate);
			((Transform)dropdownItem.rectTransform).SetParent(((Transform)itemTemplate.rectTransform).parent, false);
			((Component)dropdownItem).gameObject.SetActive(true);
			((Object)((Component)dropdownItem).gameObject).name = "Item " + items.Count + ((data.Text != null) ? (": " + data.Text) : "");
			if (Object.op_Implicit((Object)(object)dropdownItem.text))
			{
				dropdownItem.text.text = data.Text;
			}
			if (Object.op_Implicit((Object)(object)dropdownItem.image))
			{
				dropdownItem.image.sprite = data.Image;
				((Behaviour)dropdownItem.image).enabled = Object.op_Implicit((Object)(object)dropdownItem.image.sprite);
			}
			dropdownItem.Value = data.Value;
			items.Add(dropdownItem);
			return dropdownItem;
		}

		private void AlphaFadeList(float duration, float alpha)
		{
			CanvasGroup component = m_Dropdown.GetComponent<CanvasGroup>();
			AlphaFadeList(duration, component.alpha, alpha);
		}

		private void AlphaFadeList(float duration, float start, float end)
		{
			if (!end.Equals(start))
			{
				FloatTween info = new FloatTween
				{
					duration = duration,
					startValue = start,
					targetValue = end
				};
				info.AddOnChangedCallback(SetAlpha);
				info.ignoreTimeScale = true;
				m_AlphaTweenRunner.StartTween(info);
			}
		}

		private void SetAlpha(float alpha)
		{
			if (Object.op_Implicit((Object)(object)m_Dropdown))
			{
				m_Dropdown.GetComponent<CanvasGroup>().alpha = alpha;
			}
		}

		public void Hide()
		{
			if (Object.op_Implicit((Object)(object)m_Dropdown))
			{
				AlphaFadeList(0.15f, 0f);
				if (((UIBehaviour)this).IsActive())
				{
					((MonoBehaviour)this).StartCoroutine(DelayedDestroyDropdownList(0.15f));
				}
			}
			if (Object.op_Implicit((Object)(object)m_Blocker))
			{
				DestroyBlocker(m_Blocker);
			}
			m_Blocker = null;
			((Component)((TMP_InputField)this).textViewport).gameObject.SetActive(false);
			if (Object.op_Implicit((Object)(object)m_SelectText))
			{
				((Component)m_SelectText).gameObject.SetActive(true);
			}
			((TMP_InputField)this).SetTextWithoutNotify(string.Empty);
		}

		private IEnumerator DelayedDestroyDropdownList(float delay)
		{
			yield return (object)new WaitForSecondsRealtime(delay);
			ImmediateDestroyDropdownList();
		}

		private void ImmediateDestroyDropdownList()
		{
			for (int i = 0; i < m_Items.Count; i++)
			{
				if (Object.op_Implicit((Object)(object)m_Items[i]))
				{
					DestroyItem(m_Items[i]);
				}
			}
			m_Items.Clear();
			if (Object.op_Implicit((Object)(object)m_Dropdown))
			{
				DestroyDropdownList(m_Dropdown);
			}
			m_Dropdown = null;
		}

		private void OnSelectItem(object value)
		{
			((UnityEvent<object>)m_OnItemSelected)?.Invoke(value);
			Hide();
		}

		private void ApplyOptionsFilter(string filter)
		{
			foreach (DropdownItem item in m_Items)
			{
				((Component)item).gameObject.SetActive(item.text.text.ContainsInSequence(filter, "||"));
			}
			RecalculateDropdownBounds();
		}
	}
	public class SensitivityController : MonoBehaviour
	{
		public SliderWithInput fastCoefficientInput;

		public SliderWithInput slowCoefficientInput;

		[Space]
		public GameObject container;

		public static SensitivityController Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
			fastCoefficientInput.OnValueChanged += FastCoefficientChanged;
			slowCoefficientInput.OnValueChanged += SlowCoefficientChanged;
		}

		private void OnDestroy()
		{
			Instance = null;
			fastCoefficientInput.OnValueChanged -= FastCoefficientChanged;
			slowCoefficientInput.OnValueChanged -= SlowCoefficientChanged;
		}

		private void Start()
		{
			EditorSceneCameraController.Instance.fastCoefficient = fastCoefficientInput.Value;
			EditorSceneCameraController.Instance.slowCoefficient = slowCoefficientInput.Value;
		}

		public void ToggleContainerVisibility()
		{
			container.SetActive(!container.activeSelf);
		}

		private void FastCoefficientChanged(float newValue)
		{
			EditorSceneCameraController.Instance.fastCoefficient = newValue;
		}

		private void SlowCoefficientChanged(float newValue)
		{
			EditorSceneCameraController.Instance.slowCoefficient = newValue;
		}
	}
	public class SliderWithInput : MonoBehaviour
	{
		public delegate void OnValueChangedHandler(float newValue);

		[SerializeField]
		private TMP_InputField input;

		[SerializeField]
		private Slider slider;

		[SerializeField]
		private float min;

		[SerializeField]
		private float max;

		[SerializeField]
		private float value;

		private bool skipAllNotifications;

		private bool skipComponentsNotifications;

		public float Min
		{
			get
			{
				return min;
			}
			set
			{
				if (min != value)
				{
					min = value;
					skipAllNotifications = true;
					slider.minValue = min;
					skipAllNotifications = false;
					Value = Value;
				}
			}
		}

		public float Max
		{
			get
			{
				return max;
			}
			set
			{
				if (max != value)
				{
					max = value;
					skipAllNotifications = true;
					slider.maxValue = max;
					skipAllNotifications = false;
					Value = Value;
				}
			}
		}

		public float Value
		{
			get
			{
				return value;
			}
			set
			{
				float num = Mathf.Clamp(value, Min, Max);
				if (this.value == num)
				{
					return;
				}
				this.value = num;
				if (!skipAllNotifications)
				{
					if (!skipComponentsNotifications)
					{
						skipAllNotifications = true;
						slider.value = this.value;
						input.SetTextWithoutNotify(this.value.ToString(CultureInfo.InvariantCulture));
						skipAllNotifications = false;
					}
					this.OnValueChanged?.Invoke(num);
				}
			}
		}

		public event OnValueChangedHandler OnValueChanged;

		private void Start()
		{
			skipAllNotifications = true;
			value = Mathf.Clamp(Value, Min, Max);
			slider.minValue = Min;
			slider.maxValue = Max;
			slider.value = Value;
			input.SetTextWithoutNotify(value.ToString(CultureInfo.InvariantCulture));
			skipAllNotifications = false;
		}

		public void SliderValueChange(float value)
		{
			if (!skipAllNotifications && !skipComponentsNotifications)
			{
				skipComponentsNotifications = true;
				Value = value;
				input.SetTextWithoutNotify(value.ToString(CultureInfo.InvariantCulture));
				skipComponentsNotifications = false;
			}
		}

		public void InputValueChange(string value)
		{
			if (!skipAllNotifications && !skipComponentsNotifications && float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				skipComponentsNotifications = true;
				Value = result;
				if (Value != result)
				{
					input.SetTextWithoutNotify(result.ToString(CultureInfo.InvariantCulture));
				}
				slider.value = result;
				skipComponentsNotifications = false;
			}
		}

		public void InputEndEdit(string newValue)
		{
			if (!float.TryParse(newValue, NumberStyles.Float, CultureInfo.InvariantCulture, out var _))
			{
				Value = Min;
			}
		}
	}
	public static class StringBuilderExtensions
	{
		public static StringBuilder StartBlock(this StringBuilder sb, ref int indent)
		{
			sb.L(indent).Append('{');
			indent++;
			return sb;
		}

		public static StringBuilder EndBlock(this StringBuilder sb, ref int indent)
		{
			indent--;
			sb.L(indent).Append('}');
			return sb;
		}

		public static StringBuilder L(this StringBuilder sb, int indent)
		{
			sb.AppendLine();
			if (indent == 0)
			{
				return sb;
			}
			sb.Append(' ', indent * 4);
			return sb;
		}

		public static StringBuilder A(this StringBuilder sb, string text)
		{
			return sb.Append(text);
		}
	}
	public static class StringExtensions
	{
		public static bool ContainsInSequence(this string target, string input, string delimiter = null)
		{
			if (input.Length == 0)
			{
				return true;
			}
			if (target.Length == 0)
			{
				return false;
			}
			_ = StringComparer.OrdinalIgnoreCase;
			int num = 0;
			do
			{
				int num2 = (string.IsNullOrEmpty(delimiter) ? (-1) : target.IndexOf(delimiter, num, StringComparison.OrdinalIgnoreCase));
				if (num2 == -1)
				{
					num2 = target.Length;
				}
				int i = num;
				int num3 = 0;
				for (; i < num2; i++)
				{
					if (char.ToUpperInvariant(target[i]) == char.ToUpperInvariant(input[num3]))
					{
						num3++;
					}
					if (num3 == input.Length)
					{
						return true;
					}
				}
				num = num2 + (delimiter?.Length ?? 0);
			}
			while (num < target.Length);
			return false;
		}

		public static string FormatAsSplitWords(this string str)
		{
			if (str.Length == 0)
			{
				return str;
			}
			StringBuilder stringBuilder = new StringBuilder(str.Length);
			stringBuilder.Append(char.ToUpper(str[0]));
			for (int i = 1; i < str.Length; i++)
			{
				char c = str[i];
				if (char.IsUpper(c))
				{
					stringBuilder.Append(' ');
					stringBuilder.Append(char.ToLower(c));
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			if (stringBuilder[^1] == ' ')
			{
				stringBuilder.Remove(stringBuilder.Length - 1, 1);
			}
			return stringBuilder.ToString();
		}
	}
	[RequireComponent(typeof(LayoutElement))]
	public class TargetMinSize : MonoBehaviour
	{
		public bool useHeight;

		public float heightOffset;

		public bool useWidth;

		public float widthOffset;

		public RectTransform target;

		private LayoutElement layoutElement;

		public void Awake()
		{
			layoutElement = ((Component)this).GetComponent<LayoutElement>();
		}

		public void Update()
		{
			if (Object.op_Implicit((Object)(object)layoutElement) && Object.op_Implicit((Object)(object)target))
			{
				if (useHeight)
				{
					layoutElement.minHeight = LayoutUtility.GetPreferredHeight(target) - heightOffset;
				}
				if (useWidth)
				{
					layoutElement.minWidth = LayoutUtility.GetPreferredWidth(target) - widthOffset;
				}
			}
		}
	}
	public static class TemplateHelpers
	{
		public static string EnumFlagsValue<T>(T value, string modificator) where T : Enum
		{
			int num = Convert.ToInt32(value);
			if (modificator == "r")
			{
				return $"{num}";
			}
			string name = typeof(T).Name;
			string[] names = Enum.GetNames(typeof(T));
			IList values = Enum.GetValues(typeof(T));
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < values.Count; i++)
			{
				int num2 = (int)values[i];
				if (Utils.IsPowerOfTwo(num2) && (num2 & num) == num2)
				{
					if (stringBuilder.Length > 0)
					{
						stringBuilder.Append(" | ");
					}
					stringBuilder.Append(name).Append('.').Append(names[i]);
				}
			}
			return stringBuilder.ToString();
		}

		public static string EnumValue<T>(T value, string modificator) where T : Enum
		{
			if (modificator == "r")
			{
				return $"{Convert.ToInt32(value)}";
			}
			return $"{typeof(T).Name}.{value}";
		}

		public static string StringText(string str, string modificator)
		{
			if (modificator == "r")
			{
				return str ?? "";
			}
			return "\"" + str + "\"";
		}

		public static string Vector3Text(Vector3 vector, int precision, string modificator, string subField)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			bool flag = modificator == "r";
			return subField switch
			{
				"x" => FloatInvariant(vector.x, precision) + (flag ? "" : "F"), 
				"y" => FloatInvariant(vector.y, precision) + (flag ? "" : "F"), 
				"z" => FloatInvariant(vector.z, precision) + (flag ? "" : "F"), 
				_ => "new Vector3(" + FloatInvariant(vector.x, precision) + "F, " + FloatInvariant(vector.y, precision) + "F, " + FloatInvariant(vector.z, precision) + "F)", 
			};
		}

		public static string FloatInvariant(float num, int precision)
		{
			return num.ToString("0." + "".PadLeft(precision, '#'), CultureInfo.InvariantCulture);
		}
	}
	public static class Utils
	{
		public static string GetChildPath(Transform parent, Transform child)
		{
			Transform val = child;
			List<string> list = new List<string>();
			while ((Object)(object)val != (Object)(object)parent)
			{
				list.Add(((Object)val).name);
				val = val.parent;
				if (!Object.op_Implicit((Object)(object)val))
				{
					throw new Exception(((Object)parent).name + " is not a parent of " + ((Object)child).name);
				}
			}
			list.Reverse();
			return string.Join("/", list);
		}

		public static bool IsPowerOfTwo(int value)
		{
			if (value != 0)
			{
				return (value & (value - 1)) == 0;
			}
			return false;
		}
	}
	public class Vector3InputField : MonoBehaviour
	{
		public delegate void OnChangeEvent(Vector3 value);

		public TMP_InputField xInput;

		public TMP_InputField yInput;

		public TMP_InputField zInput;

		public bool interactable;

		public OnChangeEvent onValueChanged;

		private Vector3 _currentValue;

		public Vector3 CurrentValue
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return _currentValue;
			}
			set
			{
				//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_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!(_currentValue == value) && SetValueWithoutNotifyInternal(value, forceUpdate: false))
				{
					onValueChanged?.Invoke(value);
				}
			}
		}

		private void Update()
		{
			((Selectable)xInput).interactable = interactable;
			((Selectable)yInput).interactable = interactable;
			((Selectable)zInput).interactable = interactable;
		}

		public void ClearValues()
		{
			//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)
			_currentValue = Vector3.zero;
			xInput.SetTextWithoutNotify("");
			yInput.SetTextWithoutNotify("");
			zInput.SetTextWithoutNotify("");
		}

		public void OnValueChangedX(string value)
		{
			OnValueChanged(value, Axis.X);
		}

		public void OnValueChangedY(string value)
		{
			OnValueChanged(value, Axis.Y);
		}

		public void OnValueChangedZ(string value)
		{
			OnValueChanged(value, Axis.Z);
		}

		private void OnValueChanged(string value, Axis axis)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if (float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				switch (axis)
				{
				default:
					return;
				case Axis.X:
					_currentValue.x = result;
					break;
				case Axis.Y:
					_currentValue.y = result;
					break;
				case Axis.Z:
					_currentValue.z = result;
					break;
				case Axis.XY:
					return;
				}
				onValueChanged?.Invoke(CurrentValue);
			}
		}

		public void OnEndEditX(string value)
		{
			OnEditEnd(value, Axis.X);
		}

		public void OnEndEditY(string value)
		{
			OnEditEnd(value, Axis.Y);
		}

		public void OnEndEditZ(string value)
		{
			OnEditEnd(value, Axis.Z);
		}

		private void OnEditEnd(string value, Axis axis)
		{
			if (!float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var _))
			{
				switch (axis)
				{
				case Axis.X:
					xInput.text = "0";
					break;
				case Axis.Y:
					yInput.text = "0";
					break;
				case Axis.Z:
					zInput.text = "0";
					break;
				case Axis.XY:
					break;
				}
			}
		}

		public void SetValueWithoutNotify(Vector3 value, bool forceUpdate = false)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			SetValueWithoutNotifyInternal(value, forceUpdate);
		}

		private bool SetValueWithoutNotifyInternal(Vector3 value, bool forceUpdate)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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_0101: 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_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(_currentValue.x, _currentValue.y, _currentValue.z);
			if (forceUpdate || (_currentValue.x != value.x && !xInput.isFocused))
			{
				xInput.SetTextWithoutNotify(value.x.ToString(CultureInfo.InvariantCulture));
				val.x = value.x;
			}
			if (forceUpdate || (_currentValue.y != value.y && !yInput.isFocused))
			{
				yInput.SetTextWithoutNotify(value.y.ToString(CultureInfo.InvariantCulture));
				val.y = value.y;
			}
			if (forceUpdate || (_currentValue.z != value.z && !zInput.isFocused))
			{
				zInput.SetTextWithoutNotify(value.z.ToString(CultureInfo.InvariantCulture));
				val.z = value.z;
			}
			if (_currentValue == val)
			{
				return false;
			}
			_currentValue = val;
			return true;
		}
	}
}
namespace ItemDisplayPlacementHelper.Native
{
	public static class NativeHelpers
	{
		[UnmanagedFunctionPointer(CallingConvention.ThisCall)]
		private unsafe delegate IntPtr PersistentManagerGetPathNameHandler(PersistentManager* persistentManager, StringStorageDefaultV2* returnString, int instanceID);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		private delegate void FreeAllocInternalHandler(IntPtr ptr, int label, IntPtr file, int line);

		private static readonly MethodInfo GetCachedPtr = typeof(Object).GetMethod("GetCachedPtr", (BindingFlags)(-1));

		private const int PersistentManagerGetPathNameOffset = 6809328;

		private const int FreeAllocInternalOffset = 2593600;

		private const int PersistentManagerOffset = 28557672;

		private static IntPtr PersistentManagerPtr;

		private static PersistentManagerGetPathNameHandler PersistentManagerGetPathName;

		private static FreeAllocInternalHandler FreeAllocInternal;

		private unsafe static PersistentManager* PersistentManager => *(PersistentManager**)PersistentManagerPtr.ToPointer();

		public static void Init()
		{
			IntPtr baseAddress = (Process.GetCurrentProcess().Modules.Cast<ProcessModule>().FirstOrDefault(IsUnityPlayer) ?? Process.GetCurrentProcess().MainModule).BaseAddress;
			PersistentManagerPtr = baseAddress + 28557672;
			PersistentManagerGetPathName = Marshal.GetDelegateForFunctionPointer<PersistentManagerGetPathNameHandler>(baseAddress + 6809328);
			FreeAllocInternal = Marshal.GetDelegateForFunctionPointer<FreeAllocInternalHandler>(baseAddress + 2593600);
			static bool IsUnityPlayer(ProcessModule p)
			{
				return p.ModuleName.ToLowerInvariant().Contains("unityplayer");
			}
		}

		public unsafe static string GetPathName(int instanceID)
		{
			StringStorageDefaultV2 stringStorage = default(StringStorageDefaultV2);
			PersistentManagerGetPathName(PersistentManager, &stringStorage, instanceID);
			return StringStorageToString(stringStorage, freeHeap: true);
		}

		public unsafe static List<string> GetBundleDirectories(AssetBundle assetBundle)
		{
			NativeAssetBundle* ptr = (NativeAssetBundle*)(void*)(IntPtr)GetCachedPtr.Invoke(assetBundle, Array.Empty<object>());
			Vector<PathNode> vector = ptr->archiveStorage->directoryInfo.vector;
			List<string> list = new List<string>();
			for (PathNode* ptr2 = vector.first; ptr2 != vector.last; ptr2++)
			{
				list.Add(StringStorageToString(ptr2->path, freeHeap: false));
			}
			return list;
		}

		public unsafe static Dictionary<int, string> GetBundleContainerPaths(AssetBundle assetBundle)
		{
			NativeAssetBundle* ptr = (NativeAssetBundle*)(void*)(IntPtr)GetCachedPtr.Invoke(assetBundle, Array.Empty<object>());
			Dictionary<int, string> dictionary = new Dictionary<int, string>();
			foreach (MultimapNode<StringStorageDefaultV2, AssetInfo> item in ptr->pathContainer)
			{
				dictionary[item.value.second.instanceId] = StringStorageToString(item.value.first, freeHeap: false);
			}
			return dictionary;
		}

		private unsafe static string StringStorageToString(StringStorageDefaultV2 stringStorage, bool freeHeap)
		{
			if (stringStorage.data_repr != StringRepresentation.Embedded && (stringStorage.union.heap.data == 0 || stringStorage.union.heap.size == 0L))
			{
				return "";
			}
			if (stringStorage.data_repr == StringRepresentation.Embedded)
			{
				return Marshal.PtrToStringAnsi((IntPtr)stringStorage.union.embedded.data);
			}
			string text = Marshal.PtrToStringAnsi(stringStorage.union.heap.data, (int)stringStorage.union.heap.size);
			if (text != null)
			{
				if (freeHeap)
				{
					FreeAllocInternal(stringStorage.union.heap.data, stringStorage.label, IntPtr.Zero, 0);
				}
				return text;
			}
			return "";
		}
	}
}
namespace ItemDisplayPlacementHelper.Native.Structs
{
	[StructLayout(LayoutKind.Explicit)]
	public struct ArchiveStorageReader
	{
		[FieldOffset(208)]
		public DirectoryInfo directoryInfo;
	}
	public struct AssetInfo
	{
		public int preloadIndex;

		public int preloadSize;

		public int instanceId;
	}
	public struct DirectoryInfo
	{
		public Vector<PathNode> vector;
	}
	public struct Multimap<TKey, TValue> : IEnumerable<MultimapNode<TKey, TValue>>, IEnumerable where TKey : unmanaged where TValue : unmanaged
	{
		public unsafe MultimapNode<TKey, TValue>* root;

		public int count;

		public IEnumerator<MultimapNode<TKey, TValue>> GetEnumerator()
		{
			return new MultimapEnumerator<TKey, TValue>(this);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public class MultimapEnumerator<TKey, TValue> : IEnumerator<MultimapNode<TKey, TValue>>, IEnumerator, IDisposable where TKey : unmanaged where TValue : unmanaged
	{
		private readonly Multimap<TKey, TValue> map;

		private unsafe MultimapNode<TKey, TValue>* current;

		public unsafe MultimapNode<TKey, TValue> Current => *current;

		object IEnumerator.Current => Current;

		public MultimapEnumerator(Multimap<TKey, TValue> map)
		{
			this.map = map;
		}

		public void Dispose()
		{
		}

		public unsafe bool MoveNext()
		{
			if (map.count == 0)
			{
				return false;
			}
			if (current == null)
			{
				current = map.root->left;
				return current != map.root;
			}
			if (current == map.root)
			{
				return false;
			}
			if (!current->right->isnil)
			{
				MultimapNode<TKey, TValue>* ptr = current->right;
				do
				{
					current = ptr;
					ptr = ptr->left;
				}
				while (!ptr->isnil);
			}
			else
			{
				MultimapNode<TKey, TValue>* ptr2;
				do
				{
					ptr2 = current;
					current = current->parent;
				}
				while (!current->isnil && ptr2 == current->right);
			}
			return current != map.root;
		}

		public unsafe void Reset()
		{
			current = null;
		}
	}
	public struct MultimapNode<TKey, TValue> where TKey : unmanaged where TValue : unmanaged
	{
		public unsafe MultimapNode<TKey, TValue>* left;

		public unsafe MultimapNode<TKey, TValue>* parent;

		public unsafe MultimapNode<TKey, TValue>* right;

		public byte color;

		public bool isnil;

		public unsafe fixed byte offset[6];

		public MultimapPair<TKey, TValue> value;
	}
	public struct MultimapPair<TKey, TValue>
	{
		public TKey first;

		public TValue second;
	}
	[StructLayout(LayoutKind.Explicit)]
	public struct NativeAssetBundle
	{
		[FieldOffset(104)]
		public Multimap<StringStorageDefaultV2, AssetInfo> pathContainer;

		[FieldOffset(216)]
		public unsafe ArchiveStorageReader* archiveStorage;

		[FieldOffset(272)]
		public unsafe char* assetBundleName;
	}
	[StructLayout(LayoutKind.Explicit)]
	public struct PathNode
	{
		[FieldOffset(24)]
		public StringStorageDefaultV2 path;
	}
	[StructLayout(LayoutKind.Explicit)]
	public struct PersistentManager
	{
		[FieldOffset(88)]
		public IntPtr Remapper;
	}
	[StructLayout(LayoutKind.Explicit, Pack = 8)]
	public struct StringStorageDefaultV2
	{
		[FieldOffset(0)]
		public StringStorageDefaultV2Union union;

		[FieldOffset(32)]
		public StringRepresentation data_repr;

		[FieldOffset(36)]
		public int label;
	}
	[StructLayout(LayoutKind.Explicit, Pack = 8)]
	public struct StringStorageDefaultV2Union
	{
		[FieldOffset(0)]
		public StackAllocatedRepresentationV2 embedded;

		[FieldOffset(0)]
		public HeapAllocatedRepresentationV2 heap;
	}
	public struct StackAllocatedRepresentationV2
	{
		public unsafe fixed byte data[25];
	}
	public struct HeapAllocatedRepresentationV2
	{
		public nint data;

		public ulong capacity;

		public ulong size;
	}
	public enum StringRepresentation : byte
	{
		Heap,
		Embedded,
		External
	}
	public struct Vector<T> where T : unmanaged
	{
		public unsafe T* first;

		public unsafe T* last;

		public unsafe T* end;
	}
}
namespace ItemDisplayPlacementHelper.Assets.ItemDisplayPlacementHelper
{
	[AddComponentMenu("UI/MultipleOptionsDropdown", 35)]
	[RequireComponent(typeof(RectTransform))]
	public class MultipleOptionsDropdown : Selectable, IPointerClickHandler, IEventSystemHandler, ISubmitHandler, ICancelHandler
	{
		protected internal class DropdownItem : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, ICancelHandler
		{
			[SerializeField]
			private TMP_Text m_Text;

			[SerializeField]
			private Image m_Image;

			[SerializeField]
			private RectTransform m_RectTransform;

			[SerializeField]
			private Toggle m_Toggle;

			public TMP_Text text
			{
				get
				{
					return m_Text;
				}
				set
				{
					m_Text = value;
				}
			}

			public Image image
			{
				get
				{
					return m_Image;
				}
				set
				{
					m_Image = value;
				}
			}

			public RectTransform rectTransform
			{
				get
				{
					return m_RectTransform;
				}
				set
				{
					m_RectTransform = value;
				}
			}

			public Toggle toggle
			{
				get
				{
					return m_Toggle;
				}
				set
				{
					m_Toggle = value;
				}
			}

			public virtual void OnPointerEnter(PointerEventData eventData)
			{
				EventSystem.current.SetSelectedGameObject(((Component)this).gameObject);
			}

			public virtual void OnCancel(BaseEventData eventData)
			{
				TMP_Dropdown componentInParent = ((Component)this).GetComponentInParent<TMP_Dropdown>();
				if (Object.op_Implicit((Object)(object)componentInParent))
				{
					componentInParent.Hide();
				}
			}
		}

		[Serializable]
		public class OptionData
		{
			[SerializeField]
			private string m_Text;

			[SerializeField]
			private Sprite m_Image;

			[SerializeField]
			private int m_FlagValue;

			public string text
			{
				get
				{
					return m_Text;
				}
				set
				{
					m_Text = value;
				}
			}

			public Sprite image
			{
				get
				{
					return m_Image;
				}
				set
				{
					m_Image = value;
				}
			}

			public int flagValue
			{
				get
				{
					return m_FlagValue;
				}
				set
				{
					m_FlagValue = value;
				}
			}

			public OptionData()
			{
			}

			public OptionData(string text, Sprite image, int flagValue)
			{
				this.text = text;
				this.image = image;
				this.flagValue = flagValue;
			}
		}

		[Serializable]
		public class OptionDataList
		{
			[SerializeField]
			private List<OptionData> m_Options;

			public List<OptionData> options
			{
				get
				{
					return m_Options;
				}
				set
				{
					m_Options = value;
				}
			}

			public OptionDataList()
			{
				options = new List<OptionData>();
			}
		}

		[Serializable]
		public class DropdownEvent : UnityEvent<int>
		{
		}

		[SerializeField]
		private RectTransform m_Template;

		[SerializeField]
		private TMP_Text m_CaptionText;

		[SerializeField]
		private Image m_CaptionImage;

		[SerializeField]
		private Graphic m_Placeholder;

		[Space]
		[SerializeField]
		private TMP_Text m_ItemText;

		[SerializeField]
		private Image m_ItemImage;

		[Space]
		[SerializeField]
		private int m_Value;

		[Space]
		[SerializeField]
		private OptionDataList m_Options = new OptionDataList();

		[Space]
		[SerializeField]
		private DropdownEvent m_OnValueChanged = new DropdownEvent();

		[SerializeField]
		private float m_AlphaFadeSpeed = 0.15f;

		private int valueMask;

		private GameObject m_Dropdown;

		private GameObject m_Blocker;

		private List<DropdownItem> m_Items = new List<DropdownItem>();

		private FloatTweenRunner m_AlphaTweenRunner;

		private bool validTemplate;

		private Coroutine m_Coroutine;

		private static OptionData s_NoOptionData = new OptionData("None", null, 0);

		private static OptionData s_MixedOptionData = new OptionData("Mixed", null, 0);

		private static OptionData s_AllOptionData = new OptionData("All", null, 0);

		public RectTransform template
		{
			get
			{
				return m_Template;
			}
			set
			{
				m_Template = value;
				RefreshShownValue();
			}
		}

		public TMP_Text captionText
		{
			get
			{
				return m_CaptionText;
			}
			set
			{
				m_CaptionText = value;
				RefreshShownValue();
			}
		}

		public Image captionImage
		{
			get
			{
				return m_CaptionImage;
			}
			set
			{
				m_CaptionImage = value;
				RefreshShownValue();
			}
		}

		public Graphic placeholder
		{
			get
			{
				return m_Placeholder;
			}
			set
			{
				m_Placeholder = value;
				RefreshShownValue();
			}
		}

		public TMP_Text itemText
		{
			get
			{
				return m_ItemText;
			}
			set
			{
				m_ItemText = value;
				RefreshShownValue();
			}
		}

		public Image itemImage
		{
			get
			{
				return m_ItemImage;
			}
			set
			{
				m_ItemImage = value;
				RefreshShownValue();
			}
		}

		public List<OptionData> options
		{
			get
			{
				return m_Options.options;
			}
			set
			{
				m_Options.options = value;
				RefreshShownValue();
			}
		}

		public DropdownEvent onValueChanged
		{
			get
			{
				return m_OnValueChanged;
			}
			set
			{
				m_OnValueChanged = value;
			}
		}

		public float alphaFadeSpeed
		{
			get
			{
				return m_AlphaFadeSpeed;
			}
			set
			{
				m_AlphaFadeSpeed = value;
			}
		}

		public int value
		{
			get
			{
				return m_Value;
			}
			set
			{
				SetValue(value);
			}
		}

		public bool IsExpanded => (Object)(object)m_Dropdown != (Object)null;

		public void SetValueWithoutNotify(int input)
		{
			SetValue(input, sendCallback: false);
		}

		private void SetValue(int value, bool sendCallback = true)
		{
			if (!Application.isPlaying || (value != m_Value && options.Count != 0))
			{
				m_Value = value & valueMask;
				RefreshShownValue();
				if (sendCallback)
				{
					UISystemProfilerApi.AddMarker("Dropdown.value", (Object)(object)this);
					((UnityEvent<int>)m_OnValueChanged).Invoke(m_Value);
				}
			}
		}

		protected MultipleOptionsDropdown()
		{
		}

		protected override void Awake()
		{
			if (Object.op_Implicit((Object)(object)m_CaptionImage))
			{
				((Behaviour)m_CaptionImage).enabled = (Object)(object)m_CaptionImage.sprite != (Object)null;
			}
			if (Object.op_Implicit((Object)(object)m_Template))
			{
				((Component)m_Template).gameObject.SetActive(false);
			}
		}

		protected override void Start()
		{
			m_AlphaTweenRunner = new FloatTweenRunner();
			m_AlphaTweenRunner.Init((MonoBehaviour)(object)this);
			((UIBehaviour)this).Start();
			valueMask = 0;
			foreach (OptionData option in options)
			{
				valueMask |= option.flagValue;
			}
			RefreshShownValue();
		}

		protected override void OnDisable()
		{
			ImmediateDestroyDropdownList();
			if ((Object)(object)m_Blocker != (Object)null)
			{
				DestroyBlocker(m_Blocker);
			}
			m_Blocker = null;
			((Selectable)this).OnDisable();
		}

		public void RefreshShownValue()
		{
			OptionData optionData = null;
			if (m_Value == valueMask)
			{
				optionData = s_AllOptionData;
			}
			else if (options.Count > 0 && m_Value > 0)
			{
				for (int i = 0; i < options.Count; i++)
				{
					OptionData optionData2 = options[i];
					if ((optionData2.flagValue & m_Value) == optionData2.flagValue)
					{
						optionData = (((~optionData2.flagValue & m_Value) <= 0) ? optionData2 : s_MixedOptionData);
						break;
					}
				}
			}
			else
			{
				optionData = s_NoOptionData;
			}
			if (Object.op_Implicit((Object)(object)m_CaptionText))
			{
				if (optionData != null && optionData.text != null)
				{
					m_CaptionText.text = optionData.text;
				}
				else
				{
					m_CaptionText.text = "";
				}
			}
			if (Object.op_Implicit((Object)(object)m_CaptionImage))
			{
				if (optionData != null)
				{
					m_CaptionImage.sprite = optionData.image;
				}
				else
				{
					m_CaptionImage.sprite = null;
				}
				((Behaviour)m_CaptionImage).enabled = (Object)(object)m_CaptionImage.sprite != (Object)null;
			}
			if (Object.op_Implicit((Object)(object)m_Placeholder))
			{
				((Behaviour)m_Placeholder).enabled = options.Count == 0 || m_Value == 0;
			}
		}

		public void AddOptions(List<OptionData> options)
		{
			this.options.AddRange(options);
			RefreshShownValue();
			valueMask = 0;
			foreach (OptionData option in options)
			{
				valueMask |= option.flagValue;
			}
		}

		public void ClearOptions()
		{
			options.Clear();
			m_Value = 0;
			RefreshShownValue();
		}

		private void SetupTemplate()
		{
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Expected O, but got Unknown
			validTemplate = false;
			if (!Object.op_Implicit((Object)(object)m_Template))
			{
				Debug.LogError((object)"The dropdown template is not assigned. The template needs to be assigned and must have a child GameObject with a Toggle component serving as the item.", (Object)(object)this);
				return;
			}
			GameObject gameObject = ((Component)m_Template).gameObject;
			gameObject.SetActive(true);
			Toggle componentInChildren = ((Component)m_Template).GetComponentInChildren<Toggle>();
			validTemplate = true;
			if (!Object.op_Implicit((Object)(object)componentInChildren) || (Object)(object)((Component)componentInChildren).transform == (Object)(object)template)
			{
				validTemplate = false;
				Debug.LogError((object)"The dropdown template is not valid. The template must have a child GameObject with a Toggle component serving as the item.", (Object)(object)template);
			}
			else if (!(((Component)componentInChildren).transform.parent is RectTransform))
			{
				validTemplate = false;
				Debug.LogError((object)"The dropdown template is not valid. The child GameObject with a Toggle component (the item) must have a RectTransform on its parent.", (Object)(object)template);
			}
			else if ((Object)(object)itemText != (Object)null && !itemText.transform.IsChildOf(((Component)componentInChildren).transform))
			{
				validTemplate = false;
				Debug.LogError((object)"The dropdown template is not valid. The Item Text must be on the item GameObject or children of it.", (Object)(object)template);
			}
			else if ((Object)(object)itemImage != (Object)null && !((Component)itemImage).transform.IsChildOf(((Component)componentInChildren).transform))
			{
				validTemplate = false;
				Debug.LogError((object)"The dropdown template is not valid. The Item Image must be on the item GameObject or children of it.", (Object)(object)template);
			}
			if (!validTemplate)
			{
				gameObject.SetActive(false);
				return;
			}
			DropdownItem dropdownItem = ((Component)componentInChildren).gameObject.AddComponent<DropdownItem>();
			dropdownItem.text = m_ItemText;
			dropdownItem.image = m_ItemImage;
			dropdownItem.toggle = componentInChildren;
			dropdownItem.rectTransform = (RectTransform)((Component)componentInChildren).transform;
			Canvas val = null;
			Transform parent = ((Transform)m_Template).parent;
			while ((Object)(object)parent != (Object)null)
			{
				val = ((Component)parent).GetComponent<Canvas>();
				if ((Object)(object)val != (Object)null)
				{
					break;
				}
				parent = parent.parent;
			}
			Canvas orAddComponent = GetOrAddComponent<Canvas>(gameObject);
			orAddComponent.overrideSorting = true;
			orAddComponent.sortingOrder = 30000;
			if ((Object)(object)val != (Object)null)
			{
				Component[] components = (Component[])(object)((Component)val).GetComponents<BaseRaycaster>();
				Component[] array = components;
				for (int i = 0; i < array.Length; i++)
				{
					Type type = ((object)array[i]).GetType();
					if ((Object)(object)gameObject.GetComponent(type) == (Object)null)
					{
						gameObject.AddComponent(type);
					}
				}
			}
			else
			{
				GetOrAddComponent<GraphicRaycaster>(gameObject);
			}
			GetOrAddComponent<CanvasGroup>(gameObject);
			gameObject.SetActive(false);
			validTemplate = true;
		}

		private static T GetOrAddComponent<T>(GameObject go) where T : Component
		{
			T val = go.GetComponent<T>();
			if (!Object.op_Implicit((Object)(object)val))
			{
				val = go.AddComponent<T>();
			}
			return val;
		}

		public virtual void OnPointerClick(PointerEventData eventData)
		{
			Show();
		}

		public virtual void OnSubmit(BaseEventData eventData)
		{
			Show();
		}

		public virtual void OnCancel(BaseEventData eventData)
		{
			Hide();
		}

		public void Show()
		{
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03df: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04be: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04db: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0506: Unknown result type (might be due to invalid IL or missing references)
			//IL_050f: Unknown result type (might be due to invalid IL or missing references)
			//IL_051b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0529: Unknown result type (might be due to invalid IL or missing references)
			//IL_0533: Unknown result type (might be due to invalid IL or missing references)
			//IL_053a: Unknown result type (might be due to invalid IL or missing references)
			//IL_041e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			//IL_043b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0440: Unknown result type (might be due to invalid IL or missing references)
			if (m_Coroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(m_Coroutine);
				ImmediateDestroyDropdownList();
			}
			if (!((UIBehaviour)this).IsActive() || !((Selectable)this).IsInteractable() || (Object)(object)m_Dropdown != (Object)null)
			{
				return;
			}
			Canvas[] componentsInParent = ((Component)this).gameObject.GetComponentsInParent<Canvas>(false);
			if (componentsInParent.Length == 0)
			{
				return;
			}
			Canvas val = componentsInParent[^1];
			for (int i = 0; i < componentsInParent.Length; i++)
			{
				if (componentsInParent[i].isRootCanvas)
				{
					val = componentsInParent[i];
					break;
				}
			}
			if (!validTemplate)
			{
				SetupTemplate();
				if (!validTemplate)
				{
					return;
				}
			}
			((Component)m_Template).gameObject.SetActive(true);
			((Component)m_Template).GetComponent<Canvas>().sortingLayerID = val.sortingLayerID;
			m_Dropdown = CreateDropdownList(((Component)m_Template).gameObject);
			((Object)m_Dropdown).name = "Dropdown List";
			m_Dropdown.SetActive(true);
			Transform transform = m_Dropdown.transform;
			RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			((Transform)val2).SetParent(((Component)m_Template).transform.parent, false);
			DropdownItem componentInChildren = m_Dropdown.GetComponentInChildren<DropdownItem>();
			Transform transform2 = ((Component)((Transform)componentInChildren.rectTransform).parent).gameObject.transform;
			RectTransform val3 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
			((Component)componentInChildren.rectTransform).gameObject.SetActive(true);
			Rect rect = val3.rect;
			Rect rect2 = componentInChildren.rectTransform.rect;
			Vector2 val4 = ((Rect)(ref rect2)).min - ((Rect)(ref rect)).min + Vector2.op_Implicit(((Transform)componentInChildren.rectTransform).localPosition);
			Vector2 val5 = ((Rect)(ref rect2)).max - ((Rect)(ref rect)).max + Vector2.op_Implicit(((Transform)componentInChildren.rectTransform).localPosition);
			Vector2 size = ((Rect)(ref rect2)).size;
			m_Items.Clear();
			Toggle val6 = null;
			for (int j = 0; j < options.Count; j++)
			{
				OptionData data = options[j];
				DropdownItem dropdownItem = AddItem(data, (value & data.flagValue) > 0, componentInChildren, m_Items);
				if (!((Object)(object)dropdownItem == (Object)null))
				{
					((UnityEvent<bool>)(object)dropdownItem.toggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool value)
					{
						OntemToggle(value, data.flagValue);
					});
					if (dropdownItem.toggle.isOn)
					{
						((Selectable)dropdownItem.toggle).Select();
					}
					if ((Object)(object)val6 != (Object)null)
					{
						Navigation navigation = ((Selectable)val6).navigation;
						Navigation navigation2 = ((Selectable)dropdownItem.toggle).navigation;
						((Navigation)(ref navigation)).mode = (Mode)4;
						((Navigation)(ref navigation2)).mode = (Mode)4;
						((Navigation)(ref navigation)).selectOnDown = (Selectable)(object)dropdownItem.toggle;
						((Navigation)(ref navigation)).selectOnRight = (Selectable)(object)dropdownItem.toggle;
						((Navigation)(ref navigation2)).selectOnLeft = (Selectable)(object)val6;
						((Navigation)(ref navigation2)).selectOnUp = (Selectable)(object)val6;
						((Selectable)val6).navigation = navigation;
						((Selectable)dropdownItem.toggle).navigation = navigation2;
					}
					val6 = dropdownItem.toggle;
				}
			}
			Vector2 sizeDelta = val3.sizeDelta;
			sizeDelta.y = size.y * (float)m_Items.Count + val4.y - val5.y;
			val3.sizeDelta = sizeDelta;
			Rect rect3 = val2.rect;
			float height = ((Rect)(ref rect3)).height;
			rect3 = val3.rect;
			float num = height - ((Rect)(ref rect3)).height;
			if (num > 0f)
			{
				val2.sizeDelta = new Vector2(val2.sizeDelta.x, val2.sizeDelta.y - num);
			}
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			val2.GetWorldCorners(array);
			Transform transform3 = ((Component)val).transform;
			RectTransform val7 = (RectTransform)(object)((transform3 is RectTransform) ? transform3 : null);
			Rect rect4 = val7.rect;
			for (int num2 = 0; num2 < 2; num2++)
			{
				bool flag = false;
				for (int num3 = 0; num3 < 4; num3++)
				{
					Vector3 val8 = ((Transform)val7).InverseTransformPoint(array[num3]);
					float num4 = ((Vector3)(ref val8))[num2];
					Vector2 val9 = ((Rect)(ref rect4)).min;
					if (num4 < ((Vector2)(ref val9))[num2])
					{
						float num5 = ((Vector3)(ref val8))[num2];
						val9 = ((Rect)(ref rect4)).min;
						if (!Mathf.Approximately(num5, ((Vector2)(ref val9))[num2]))
						{
							goto IL_0452;
						}
					}
					float num6 = ((Vector3)(ref val8))[num2];
					val9 = ((Rect)(ref rect4)).max;
					if (!(num6 > ((Vector2)(ref val9))[num2]))
					{
						continue;
					}
					float num7 = ((Vector3)(ref val8))[num2];
					val9 = ((Rect)(ref rect4)).max;
					if (Mathf.Approximately(num7, ((Vector2)(ref val9))[num2]))
					{
						continue;
					}
					goto IL_0452;
					IL_0452:
					flag = true;
					break;
				}
				if (flag)
				{
					RectTransformUtility.FlipLayoutOnAxis(val2, num2, false, false);
				}
			}
			for (int num8 = 0; num8 < m_Items.Count; num8++)
			{
				RectTransform rectTransform = m_Items[num8].rectTransform;
				rectTransform.anchorMin = new Vector2(rectTransform.anchorMin.x, 0f);
				rectTransform.anchorMax = new Vector2(rectTransform.anchorMax.x, 0f);
				rectTransform.anchoredPosition = new Vector2(rectTransform.anchoredPosition.x, val4.y + size.y * (float)(m_Items.Count - 1 - num8) + size.y * rectTransform.pivot.y);
				rectTransform.sizeDelta = new Vector2(rectTransform.sizeDelta.x, size.y);
			}
			AlphaFadeList(m_AlphaFadeSpeed, 0f, 1f);
			((Component)m_Template).gameObject.SetActive(false);
			((Component)componentInChildren).gameObject.SetActive(false);
			m_Blocker = CreateBlocker(val);
		}

		protected virtual GameObject CreateBlocker(Canvas rootCanvas)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			GameObject val = new GameObject("Blocker");
			RectTransform obj = val.AddComponent<RectTransform>();
			((Transform)obj).SetParent(((Component)rootCanvas).transform, false);
			obj.anchorMin = Vector2.op_Implicit(Vector3.zero);
			obj.anchorMax = Vector2.op_Implicit(Vector3.one);
			obj.sizeDelta = Vector2.zero;
			Canvas obj2 = val.AddComponent<Canvas>();
			obj2.overrideSorting = true;
			Canvas component = m_Dropdown.GetComponent<Canvas>();
			obj2.sortingLayerID = component.sortingLayerID;
			obj2.sortingOrder = component.sortingOrder - 1;
			Canvas val2 = null;
			Transform parent = ((Transform)m_Template).parent;
			while ((Object)(object)parent != (Object)null)
			{
				val2 = ((Component)parent).GetComponent<Canvas>();
				if ((Object)(object)val2 != (Object)null)
				{
					break;
				}
				parent = parent.parent;
			}
			if ((Object)(object)val2 != (Object)null)
			{
				Component[] components = (Component[])(object)((Component)val2).GetComponents<BaseRaycaster>();
				Component[] array = components;
				for (int i = 0; i < array.Length; i++)
				{
					Type type = ((object)array[i]).GetType();
					if ((Object)(object)val.GetComponent(type) == (Object)null)
					{
						val.AddComponent(type);
					}
				}
			}
			else
			{
				GetOrAddComponent<GraphicRaycaster>(val);
			}
			((Graphic)val.AddComponent<Image>()).color = Color.clear;
			((UnityEvent)val.AddComponent<Button>().onClick).AddListener(new UnityAction(Hide));
			return val;
		}

		protected virtual void DestroyBlocker(GameObject blocker)
		{
			Object.Destroy((Object)(object)blocker);
		}

		protected virtual GameObject CreateDropdownList(GameObject template)
		{
			return Object.Instantiate<GameObject>(template);
		}

		protected virtual void DestroyDropdownList(GameObject dropdownList)
		{
			Object.Destroy((Object)(object)dropdownList);
		}

		protected virtual DropdownItem CreateItem(DropdownItem itemTemplate)
		{
			return Object.Instantiate<DropdownItem>(itemTemplate);
		}

		protected virtual void DestroyItem(DropdownItem item)
		{
		}

		private DropdownItem AddItem(OptionData data, bool selected, DropdownItem itemTemplate, List<DropdownItem> items)
		{
			DropdownItem dropdownItem = CreateItem(itemTemplate);
			((Transform)dropdownItem.rectTransform).SetParent(((Transform)itemTemplate.rectTransform).parent, false);
			((Component)dropdownItem).gameObject.SetActive(true);
			((Object)((Component)dropdownItem).gameObject).name = "Item " + items.Count + ((data.text != null) ? (": " + data.text) : "");
			if ((Object)(object)dropdownItem.toggle != (Object)null)
			{
				dropdownItem.toggle.isOn = selected;
			}
			if (Object.op_Implicit((Object)(object)dropdownItem.text))
			{
				dropdownItem.text.text = data.text;
			}
			if (Object.op_Implicit((Object)(object)dropdownItem.image))
			{
				dropdownItem.image.sprite = data.image;
				((Behaviour)dropdownItem.image).enabled = (Object)(object)dropdownItem.image.sprite != (Object)null;
			}
			items.Add(dropdownItem);
			return dropdownItem;
		}

		private void AlphaFadeList(float duration, float alpha)
		{
			CanvasGroup component = m_Dropdown.GetComponent<CanvasGroup>();
			AlphaFadeList(duration, component.alpha, alpha);
		}

		private void AlphaFadeList(float duration, float start, float end)
		{
			if (!end.Equals(start))
			{
				FloatTween info = new FloatTween
				{
					duration = duration,
					startValue = start,
					targetValue = end
				};
				info.AddOnChangedCallback(SetAlpha);
				info.ignoreTimeScale = true;
				m_AlphaTweenRunner.StartTween(info);
			}
		}

		private void SetAlpha(float alpha)
		{
			if (Object.op_Implicit((Object)(object)m_Dropdown))
			{
				m_Dropdown.GetComponent<CanvasGroup>().alpha = alpha;
			}
		}

		public void Hide()
		{
			if (m_Coroutine != null)
			{
				return;
			}
			if ((Object)(object)m_Dropdown != (Object)null)
			{
				AlphaFadeList(m_AlphaFadeSpeed, 0f);
				if (((UIBehaviour)this).IsActive())
				{
					m_Coroutine = ((MonoBehaviour)this).StartCoroutine(DelayedDestroyDropdownList(m_AlphaFadeSpeed));
				}
			}
			if ((Object)(object)m_Blocker != (Object)null)
			{
				DestroyBlocker(m_Blocker);
			}
			m_Blocker = null;
			((Selectable)this).Select();
		}

		private IEnumerator DelayedDestroyDropdownList(float delay)
		{
			yield return (object)new WaitForSecondsRealtime(delay);
			ImmediateDestroyDropdownList();
		}

		private void ImmediateDestroyDropdownList()
		{
			for (int i = 0; i < m_Items.Count; i++)
			{
				if ((Object)(object)m_Items[i] != (Object)null)
				{
					DestroyItem(m_Items[i]);
				}
			}
			m_Items.Clear();
			if ((Object)(object)m_Dropdown != (Object)null)
			{
				DestroyDropdownList(m_Dropdown);
			}
			if (m_AlphaTweenRunner != null)
			{
				m_AlphaTweenRunner.StopTween();
			}
			m_Dropdown = null;
			m_Coroutine = null;
		}

		private void OntemToggle(bool on, int flagValue)
		{
			if (on)
			{
				value |= flagValue;
			}
			else
			{
				value &= ~flagValue;
			}
		}
	}
}
namespace ItemDisplayPlacementHelper.Editable
{
	public class EditableDisplayRuleGroup
	{
		public Object KeyAsset { get; set; }

		public IDRSKeyAssetReference KeyAssetAddress { get; set; }

		public List<EditableItemDisplayRule> Rules { get; } = new List<EditableItemDisplayRule>();

		public bool Enabled { get; private set; }

		public static EditableDisplayRuleGroup From(KeyAssetRuleGroup keyAssetRuleGroup)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			EditableDisplayRuleGroup obj = new EditableDisplayRuleGroup
			{
				KeyAsset = keyAssetRuleGroup.keyAsset
			};
			IDRSKeyAssetReference keyAssetAddress = keyAssetRuleGroup.keyAssetAddress;
			obj.KeyAssetAddress = new IDRSKeyAssetReference((keyAssetAddress != null) ? ((AssetReference)keyAssetAddress).AssetGUID : null);
			EditableDisplayRuleGroup editableDisplayRuleGroup = obj;
			if (!((DisplayRuleGroup)(ref keyAssetRuleGroup.displayRuleGroup)).isEmpty)
			{
				editableDisplayRuleGroup.Rules.AddRange(keyAssetRuleGroup.displayRuleGroup.rules.Select(EditableItemDisplayRule.From));
			}
			return editableDisplayRuleGroup;
		}

		public void Enable(CharacterModel characterModel)
		{
			if (Enabled)
			{
				return;
			}
			Enabled = true;
			foreach (EditableItemDisplayRule rule in Rules)
			{
				rule.Enable(characterModel);
			}
		}

		public void Disable(CharacterModel characterModel)
		{
			if (!Enabled)
			{
				return;
			}
			Enabled = false;
			foreach (EditableItemDisplayRule rule in Rules)
			{
				rule.Disable(characterModel);
			}
		}
	}
	public class EditableItemDisplayRule
	{
		public ItemDisplayRuleType ruleType;

		public GameObject followerPrefab;

		public AssetReferenceGameObject followerPrefabAddress;

		public string childName;

		public Vector3 localPos;

		public Vector3 localAngles;

		public Vector3 localScale;

		public LimbFlags limbMask;

		public string assetBundle;

		public string assetPath;

		public bool referenceDiscovered;

		public bool enabled;

		public GameObject instance;

		public static EditableItemDisplayRule From(ItemDisplayRule itemDisplayRule)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			EditableItemDisplayRule obj = new EditableItemDisplayRule
			{
				childName = itemDisplayRule.childName,
				followerPrefab = itemDisplayRule.followerPrefab
			};
			AssetReferenceGameObject obj2 = itemDisplayRule.followerPrefabAddress;
			obj.followerPrefabAddress = new AssetReferenceGameObject((obj2 != null) ? ((AssetReference)obj2).AssetGUID : null);
			obj.limbMask = itemDisplayRule.limbMask;
			obj.localAngles = itemDisplayRule.localAngles;
			obj.localPos = itemDisplayRule.localPos;
			obj.localScale = itemDisplayRule.localScale;
			obj.ruleType = itemDisplayRule.ruleType;
			AssetReferenceGameObject obj3 = itemDisplayRule.followerPrefabAddress;
			obj.referenceDiscovered = !string.IsNullOrEmpty((obj3 != null) ? ((AssetReference)obj3).AssetGUID : null);
			return obj;
		}

		public void Enable(CharacterModel characterModel)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (enabled)
			{
				return;
			}
			enabled = true;
			ItemDisplayRuleType val = ruleType;
			if ((int)val != 0)
			{
				if ((int)val == 1)
				{
					characterModel.limbFlagSet.AddFlags(limbMask);
					characterModel.materialsDirty = true;
				}
			}
			else
			{
				TrySpawnInstance(characterModel);
			}
		}

		public void TrySpawnInstance(CharacterModel characterModel)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: 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_00a9: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)instance))
			{
				return;
			}
			Transform transform = ((IEnumerable<NameTransformPair>)characterModel.childLocator.transformPairs).FirstOrDefault((Func<NameTransformPair, bool>)((NameTransformPair p) => p.name == childName)).transform;
			if (!Object.op_Implicit((Object)(object)transform))
			{
				return;
			}
			ParentedPrefabDisplay val = default(ParentedPrefabDisplay);
			Quaternion val2 = Quaternion.Euler(localAngles);
			if (Object.op_Implicit((Object)(object)followerPrefab))
			{
				((ParentedPrefabDisplay)(ref val)).Apply(characterModel, followerPrefab, transform, localPos, val2, localScale);
			}
			else
			{
				AssetReferenceGameObject obj = followerPrefabAddress;
				if (obj == null || !((AssetReference)obj).RuntimeKeyIsValid())
				{
					return;
				}
				((ParentedPrefabDisplay)(ref val)).Apply(characterModel, (AssetReferenceT<GameObject>)(object)followerPrefabAddress, transform, localPos, val2, localScale);
				followerPrefab = val.prefabReference.Result;
			}
			instance = ((ParentedPrefabDisplay)(ref val)).instance;
			ItemFollower component = instance.GetComponent<ItemFollower>();
			if (Object.op_Implicit((Object)(object)component) && Object.op_Implicit((Object)(object)component.followerPrefab))
			{
				((MonoBehaviour)component).StartCoroutine(AddComponentToFollowerInstanceCoroutine(component));
			}
		}

		public void Disable(CharacterModel characterModel)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Invalid comparison between Unknown and I4
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (enabled)
			{
				enabled = false;
				if (Object.op_Implicit((Object)(object)instance))
				{
					Object.Destroy((Object)(object)instance);
					instance = null;
				}
				if ((int)ruleType == 1)
				{
					characterModel.limbFlagSet.RemoveFlags(limbMask);
					characterModel.materialsDirty = true;
				}
			}
		}

		private IEnumerator AddComponentToFollowerInstanceCoroutine(ItemFollower itemFollower)
		{
			yield return (object)new WaitUntil((Func<bool>)(() => Object.op_Implicit((Object)(object)itemFollower.followerInstance)));
			if (!Object.op_Implicit((Object)(object)itemFollower.followerInstance.GetComponent<MatchLocalScale>()))
			{
				itemFollower.followerInstance.AddComponent<MatchLocalScale>().target = ((Component)itemFollower).transform;
			}
		}
	}
	public class EditableItemDisplayRuleSet
	{
		public List<EditableDisplayRuleGroup> DisplayRuleGroups { get; } = new List<EditableDisplayRuleGroup>();

		public static EditableItemDisplayRuleSet From(ItemDisplayRuleSet ruleSet)
		{
			//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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			EditableItemDisplayRuleSet editableItemDisplayRuleSet = new EditableItemDisplayRuleSet();
			if (Object.op_Implicit((Object)(object)ruleSet))
			{
				KeyAssetRuleGroup[] keyAssetRuleGroups = ruleSet.keyAssetRuleGroups;
				foreach (KeyAssetRuleGroup val in keyAssetRuleGroups)
				{
					if (!(val.keyAsset is ItemDef) && !(val.keyAsset is EquipmentDef))
					{
						ItemDisplayPlacementHelperPlugin.InstanceLogger.LogWarning((object)"Rule group keyAsset is invalid, skipping");
					}
					else
					{
						editableItemDisplayRuleSet.DisplayRuleGroups.Add(EditableDisplayRuleGroup.From(val));
					}
				}
			}
			return editableItemDisplayRuleSet;
		}
	}
}
namespace ItemDisplayPlacementHelper.Dialogs
{
	public class DialogController : MonoBehaviour
	{
		public GameObject container;

		public Transform background;

		[Space]
		public GameObject textPrefab;

		public GameObject prefabPickerPrefab;

		public GameObject keyAssetPickerPrefab;

		public GameObject filePathPickerPrefab;

		public GameObject exportPrefab;

		public GameObject importPrefab;

		private static DialogController Instance { get; set; }

		private void Awake()
		{
			Instance = this;
		}

		private void OnDestroy()
		{
			Instance = null;
		}

		public static void ShowError(string text)
		{
			if (Object.op_Implicit((Object)(object)Instance))
			{
				SpawnDialog<TextDialogController>(Instance.textPrefab).textComponent.text = text;
			}
		}

		public static void ShowPrefabPicker(string guid, string assetBundle, string path, PrefabPickHandler onPick)
		{
			if (Object.op_Implicit((Object)(object)Instance))
			{
				PrefabPickerDialogController prefabPickerDialogController = SpawnDialog<PrefabPickerDialogController>(Instance.prefabPickerPrefab);
				prefabPickerDialogController.onPick = onPick;
				if (!string.IsNullOrEmpty(guid))
				{
					prefabPickerDialogController.typeDropdown.value = 0;
					prefabPickerDialogController.guidInput.text = guid;
				}
				else
				{
					prefabPickerDialogController.typeDropdown.value = 1;
					prefabPickerDialogController.assetBundleInput.text = assetBundle;
					prefabPickerDialogController.pathInput.text = path;
				}
			}
		}

		public static void ShowKeyAssetPicker(IEnumerable<Object> rows, KeyAssetPickHandler onPick)
		{
			if (Object.op_Implicit((Object)(object)Instance))
			{
				KeyAssetPickerDialogController keyAssetPickerDialogController = SpawnDialog<KeyAssetPickerDialogController>(Instance.keyAssetPickerPrefab);
				keyAssetPickerDialogController.onPick = onPick;
				keyAssetPickerDialogController.CreateRows(rows);
			}
		}

		public static void ShowFilePathPicker(bool selectFile, bool allowNonExisting, string fileExtension, string defaultFileName, FilePathPickHandler onPick)
		{
			if (Object.op_Implicit((Object)(object)Instance))
			{
				FilePathPickerDialogController filePathPickerDialogController = SpawnDialog<FilePathPickerDialogController>(Instance.filePathPickerPrefab);
				filePathPickerDialogController.onPick = onPick;
				filePathPickerDialogController.selectFile = selectFile;
				filePathPickerDialogController.allowNotExisting = allowNonExisting;
				filePathPickerDialogController.fileExtension = fileExtension;
				filePathPickerDialogController.fileField.text = defaultFileName ?? "";
			}
		}

		public static void ShowExport(ExportHandler onExport)
		{
			if (Object.op_Implicit((Object)(object)Instance))
			{
				SpawnDialog<ExportDialogController>(Instance.exportPrefab).onExport = onExport;
			}
		}

		public static void ShowImport(ImportHandler onImport)
		{
			if (Object.op_Implicit((Object)(object)Instance))
			{
				SpawnDialog<ImportDialogController>(Instance.importPrefab).onImport = onImport;
			}
		}

		public static void HideTopmost()
		{
			if (!Object.op_Implicit((Object)(object)Instance))
			{
				return;
			}
			int childCount = Instance.container.transform.childCount;
			if (childCount != 1)
			{
				Object.Destroy((Object)(object)((Component)Instance.container.transform.GetChild(childCount - 1)).gameObject);
				Instance.background.SetSiblingIndex(childCount - 3);
				if (childCount == 2)
				{
					Instance.container.SetActive(false);
				}
			}
		}

		private static T SpawnDialog<T>(GameObject prefab) where T : MonoBehaviour
		{
			Instance.container.SetActive(true);
			Instance.background.SetAsLastSibling();
			return Object.Instantiate<GameObject>(prefab, Instance.container.transform).GetComponent<T>();
		}
	}
	public delegate void ExportHandler(string path, AssetsToExport assetsToExport, bool generateClass, string @namespace, bool withSkin);
	public class ExportDialogController : MonoBehaviour
	{
		public TMP_Dropdown exportSourceDropdown;

		public TMP_InputField pathField;

		public Toggle withSkinToggle;

		public Toggle classToggle;

		public TMP_InputField namespaceField;

		public ExportHandler onExport;

		public void Awake()
		{
			exportSourceDropdown.AddOptions(((IEnumerable<string>)Enum.GetNames(typeof(AssetsToExport))).Select((Func<string, OptionData>)((string name) => new OptionData(name.FormatAsSplitWords()))).ToList());
			exportSourceDropdown.value = (int)ConfigHelper.ExportAssetsToExport.Value;
			classToggle.isOn = ConfigHelper.ExportGenerateClass.Value;
			namespaceField.text = ConfigHelper.ExportNamespace.Value;
			withSkinToggle.isOn = ConfigHelper.ExportWithSkin.Value;
		}

		public void SelectPath()
		{
			DialogController.ShowFilePathPicker(selectFile: true, allowNonExisting: true, "idrsjson", ModelPicker.Instance.ModelInfo.bodyName + "IDRS.idrsjson", delegate(string path)
			{
				pathField.text = path;
			});
		}

		public void Ok()
		{
			string text = pathField.text;
			if (text.Length == 0 || text.EndsWith('\\'))
			{
				DialogController.ShowError("File name not specified");
				return;
			}
			text = Path.ChangeExtension(text, ".idrsjson");
			if (Directory.Exists(pathField.text))
			{
				DialogController.ShowError("There is already a directory with specified file name");
				return;
			}
			if (!Directory.Exists(Path.GetDirectoryName(pathField.text)))
			{
				DialogController.ShowError("Directory does not exist");
				return;
			}
			AssetsToExport value = (AssetsToExport)exportSourceDropdown.value;
			bool isOn = classToggle.isOn;
			string text2 = namespaceField.text;
			bool isOn2 = withSkinToggle.isOn;
			ConfigHelper.ConfigFile.SaveOnConfigSet = false;
			ConfigHelper.ExportAssetsToExport.Value = value;
			ConfigHelper.ExportGenerateClass.Value = isOn;
			ConfigHelper.ExportNamespace.Value = text2;
			ConfigHelper.ExportWithSkin.Value = isOn2;
			ConfigHelper.ConfigFile.SaveOnConfigSet = true;
			ConfigHelper.ConfigFile.Save();
			onExport?.Invoke(pathField.text, value, isOn, text2, isOn2);
			DialogController.HideTopmost();
		}

		public void Cancel()
		{
			DialogController.HideTopmost();
		}
	}
	public delegate void FilePathPickHandler(string path);
	public class FilePathPickerDialogController : MonoBehaviour
	{
		public TMP_InputField pathField;

		public TMP_InputField fileField;

		public TMP_Text fileFieldHeader;

		public TMP_Text dialogHeader;

		public GameObject rowPrefab;

		public Transform container;

		public Sprite folderIcon;

		public Sprite fileIcon;

		public FilePathPickHandler onPick;

		[NonSerialized]
		public bool selectFile;

		[NonSerialized]
		public bool allowNotExisting;

		[NonSerialized]
		public string fileExtension;

		private string lastValidPath;

		private readonly List<FileRowController> rows = new List<FileRowController>();

		public void Start()
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			lastValidPath = ConfigHelper.FilePickerLastPath.Value ?? "";
			if (!Directory.Exists(lastValidPath))
			{
				lastValidPath = Environment.CurrentDirectory;
			}
			pathField.text = lastValidPath;
			Refresh();
			if (selectFile)
			{
				fileFieldHeader.text = "File";
				dialogHeader.text = "Select file";
			}
			else
			{
				fileFieldHeader.text = "Folder";
				dialogHeader.text = "Select folder";
			}
			char[] invalidPathChars = Path.GetInvalidPathChars();
			char[] invalidFileChars = Path.GetInvalidFileNameChars();
			TMP_InputField obj = pathField;
			obj.onValidateInput = (OnValidateInput)Delegate.Combine((Delegate?)(object)obj.onValidateInput, (Delegate?)(OnValidateInput)((string text, int pos, char ch) => (!invalidPathChars.Contains(ch)) ? ch : '\0'));
			TMP_InputField obj2 = fileField;
			obj2.onValidateInput = (OnValidateInput)Delegate.Combine((Delegate?)(object)obj2.onValidateInput, (Delegate?)(OnValidateInput)((string text, int pos, char ch) => (!invalidFileChars.Contains(ch)) ? ch : '\0'));
		}

		public void Refresh()
		{
			if (string.IsNullOrEmpty(lastValidPath))
			{
				DriveInfo[] drives = DriveInfo.GetDrives();
				EnsureRowCount(drives.Length);
				for (int i = 0; i < drives.Length; i++)
				{
					FileRowController fileRowController = rows[i];
					fileRowController.text.text = drives[i].VolumeLabel;
					fileRowController.part = drives[i].RootDirectory.Name;
					fileRowController.icon.sprite = folderIcon;
					fileRowController.isFile = false;
				}
				return;
			}
			string[] directories = Directory.GetDirectories(lastValidPath, "*", new EnumerationOptions
			{
				IgnoreInaccessible = true
			});
			string[] array = (selectFile ? Directory.GetFiles(lastValidPath, string.IsNullOrEmpty(fileExtension) ? "*" : ("*." + fileExtension), new EnumerationOptions
			{
				IgnoreInaccessible = true
			}) : Array.Empty<string>());
			EnsureRowCount(directories.Length + array.Length);
			for (int j = 0; j < directories.Length; j++)
			{
				FileRowController fileRowController2 = rows[j];
				fileRowController2.text.text = Path.GetFileName(directories[j]);
				fileRowController2.part = fileRowController2.text.text;
				fileRowController2.icon.sprite = folderIcon;
				fileRowController2.isFile = false;
			}
			for (int k = 0; k < array.Length; k++)
			{
				FileRowController fileRowController3 = rows[directories.Length + k];
				fileRowController3.text.text = Path.GetFileName(array[k]);
				fileRowController3.part = fileRowController3.text.text;
				fileRowController3.icon.sprite = fileIcon;
				fileRowController3.isFile = true;
			}
		}

		private void EnsureRowCount(int length)
		{
			if (rows.Count < length)
			{
				for (int i = rows.Count; i < length; i++)
				{
					GameObject val = Object.Instantiate<GameObject>(rowPrefab, container);
					val.SetActive(true);
					rows.Add(val.GetComponent<FileRowController>());
				}
			}
			else
			{
				for (int num = rows.Count - 1; num >= length; num--)
				{
					Object.Destroy((Object)(object)((Component)rows[num]).gameObject);
					rows.RemoveAt(num);
				}
			}
		}

		public void ValidatePath()
		{
			if (Directory.Exists(pathField.text))
			{
				if (pathField.text.EndsWith(':'))
				{
					lastValidPath = $"{pathField.text}{Path.DirectorySeparatorChar}";
				}
				else
				{
					lastValidPath = pathField.text;
				}
				Refresh();
			}
			else
			{
				pathField.text = lastValidPath;
			}
		}

		public void SelectRow(FileRowController row)
		{
			if (!row.isFile)
			{
				EventSystem.current.SetSelectedGameObject((GameObject)null);
				lastValidPath = (string.IsNullOrEmpty(lastValidPath) ? row.part : Path.Combine(lastValidPath, row.part));
				pathField.text = lastValidPath;
				if (!selectFile)
				{
					fileField.text = "";
				}
				Refresh();
			}
			else if (row.isFile == selectFile)
			{
				fileField.text = row.part;
			}
		}

		public void Up()
		{
			lastValidPath = Path.GetDirectoryName(lastValidPath);
			pathField.text = lastValidPath;
			Refresh();
		}

		public void Ok()
		{
			string text = (string.IsNullOrEmpty(fileField.text) ? pathField.text : Path.Combine(pathField.text, fileField.text));
			if (selectFile)
			{
				if (string.IsNullOrEmpty(fileField.text))
				{
					DialogController.ShowError("File name is required");
					return;
				}
				if (!allowNotExisting && !File.Exists(text))
				{
					DialogController.ShowError("File does not exist");
					return;
				}
				ConfigHelper.FilePickerLastPath.Value = pathField.text;
			}
			else
			{
				if (!allowNotExisting && !Directory.Exists(text))
				{
					DialogController.ShowError("Directory does not exist");
					return;
				}
				ConfigHelper.FilePickerLastPath.Value = text;
			}
			onPick?.Invoke(text);
			DialogController.HideTopmost();
		}

		public void Cancel()
		{
			DialogController.HideTopmost();
		}
	}
	public delegate void ImportHandler(string path, ImportType importType);
	public class ImportDialogController : MonoBehaviour
	{
		public TMP_Dropdown importTypeDropdown;

		public TMP_InputField pathField;

		public ImportHandler onImport;

		public void Awake()
		{
			importTypeDropdown.AddOptions(((IEnumerable<string>)Enum.GetNames(typeof(ImportType))).Select((Func<string, OptionData>)((string name) => new OptionData(name.FormatAsSplitWords()))).ToList());
			importTypeDropdown.value = (int)ConfigHelper.ImportImportType.Value;
		}

		public void SelectPath()
		{
			DialogController.ShowFilePathPicker(selectFile: true, allowNonExisting: false, "idrsjson", "", delegate(string path)
			{
				pathField.text = path;
			});
		}

		public void Ok()
		{
			if (!File.Exists(pathField.text))
			{
				DialogController.ShowError("File not found");
				return;
			}
			ImportType value = (ImportType)importTypeDropdown.value;
			ConfigHelper.ConfigFile.SaveOnConfigSet = false;
			ConfigHelper.ImportImportType.Value = value;
			ConfigHelper.ConfigFile.SaveOnConfigSet = true;
			ConfigHelper.ConfigFile.Save();
			onImport?.Invoke(pathField.text, value);
			DialogController.HideTopmost();
		}

		public void Cancel()
		{
			DialogController.HideTopmost();
		}
	}
	public delegate void KeyAssetPickHandler(Object keyAsset);
	public class KeyAssetPickerDialogController : MonoBehaviour
	{
		public TMP_InputField searchInput;

		public GameObject rowPrefab;

		public Transform container;

		public KeyAssetPickHandler onPick;

		private readonly List<KeyAssetRowController> rows = new List<KeyAssetRowController>();

		private KeyAssetRowController selectedRow;

		public void CreateRows(IEnumerable<Object> keyAssets)
		{
			foreach (KeyAssetRowController row in rows)
			{
				Object.Destroy((Object)(object)((Component)row).gameObject);
			}
			rows.Clear();
			foreach (var item6 in from a in keyAssets
				select (a: a, GetItemInfo(a)) into e
				orderby string.IsNullOrEmpty(e.Item2.name), e.Item2.name
				select e)
			{
				(Sprite, string, string) item = item6.Item2;
				Object item2 = item6.a;
				Sprite item3 = item.Item1;
				string item4 = item.Item2;
				string item5 = item.Item3;
				GameObject obj = Object.Instantiate<GameObject>(rowPrefab, container);
				KeyAssetRowController component = obj.GetComponent<KeyAssetRowController>();
				component.icon.sprite = item3;
				component.text.text = item4;
				component.subText.text = item5;
				component.keyAsset = item2;
				obj.SetActive(true);
				rows.Add(component);
			}
		}

		public void ApplyFilter(string filter)
		{
			bool flag = string.IsNullOrEmpty(filter);
			foreach (KeyAssetRowController row in rows)
			{
				bool active = flag || row.text.text.ContainsInSequence(filter) || row.subText.text.ContainsInSequence(filter);
				((Component)row).gameObject.SetActive(active);
			}
		}

		public void SelectRow(KeyAssetRowController row)
		{
			if (Object.op_Implicit((Object)(object)selectedRow))
			{
				((Selectable)selectedRow.button).interactable = true;
			}
			((Selectable)row.button).interactable = false;
			selectedRow = row;
		}

		public void Ok()
		{
			if (Object.op_Implicit((Object)(object)selectedRow))
			{
				onPick?.Invoke(selectedRow.keyAsset);
				DialogController.HideTopmost();
			}
		}

		public void Cancel()
		{
			DialogController.HideTopmost();
		}

		private (Sprite icon, string name, string subName) GetItemInfo(Object keyAsset)
		{
			ItemDef val = (ItemDef)(object)((keyAsset is ItemDef) ? keyAsset : null);
			if (val != null)
			{
				return (icon: val.pickupIconSprite, name: Language.GetString(val.nameToken), subName: ((Object)val).name);
			}
			EquipmentDef val2 = (EquipmentDef)(object)((keyAsset is EquipmentDef) ? keyAsset : null);
			if (val2 != null)
			{
				return (icon: val2.pickupIconSprite, name: Language.GetString(val2.nameToken), subName: ((Object)val2).name);
			}
			return default((Sprite, string, string));
		}
	}
	public delegate void PrefabPickHandler(GameObject gameObject, AssetReferenceGameObject reference, string assetBundle, string path);
	public class PrefabPickerDialogController : MonoBehaviour
	{
		public TMP_Dropdown typeDropdown;

		public TMP_InputField guidInput;

		public TMP_InputField assetBundleInput;

		public TMP_InputField pathInput;

		public TMP_Text errorText;

		public PrefabPickHandler onPick;

		private Dictionary<string, AssetBundle> allBundles;

		public void Awake()
		{
			typeDropdown.AddOptions(((IEnumerable<string>)Enum.GetNames(typeof(PrefabSource))).Select((Func<string, OptionData>)((string name) => new OptionData(name))).ToList());
			OnTypeChanged(0);
		}

		public void OnTypeChanged(int index)
		{
			switch ((PrefabSource)index)
			{
			case PrefabSource.Addressables:
				((Component)((Component)guidInput).transform.parent).gameObject.SetActive(true);
				((Component)((Component)assetBundleInput).transform.parent).gameObject.SetActive(false);
				((Component)((Component)pathInput).transform.parent).gameObject.SetActive(false);
				break;
			case PrefabSource.AssetBundle:
				((Component)((Component)guidInput).transform.parent).gameObject.SetActive(false);
				((Component)((Component)assetBundleInput).transform.parent).gameObject.SetActive(true);
				((Component)((Component)pathInput).transform.parent).gameObject.SetActive(true);
				break;
			}
			ResetError();
		}

		public void ResetError()
		{
			errorText.text = "";
			((Component)errorText.transform.parent).gameObject.SetActive(false);
		}

		public void Ok()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			GameObject val = null;
			AssetReferenceGameObject val2 = null;
			string text = "";
			string text2 = "";
			try
			{
				switch ((PrefabSource)typeDropdown.value)
				{
				case PrefabSource.Addressables:
					val2 = new AssetReferenceGameObject(guidInput.text);
					if (((AssetReference)val2).RuntimeKeyIsValid())
					{
						val = Addressables.LoadAssetAsync<GameObject>((object)val2).WaitForCompletion();
					}
					break;
				case PrefabSource.AssetBundle:
				{
					val2 = new AssetReferenceGameObject("");
					text = assetBundleInput.text;
					text2 = pathInput.text;
					if (allBundles == null)
					{
						allBundles = AssetBundle.GetAllLoadedAssetBundles().ToDictionary((AssetBundle b) => ((Object)b).name);
					}
					if (allBundles.TryGetValue(text, out var value))
					{
						val = value.LoadAsset<GameObject>(text2);
					}
					break;
				}
				}
			}
			catch (Exception ex)
			{
				ItemDisplayPlacementHelperPlugin.InstanceLogger.LogError((object)ex);
			}
			if (!Object.op_Implicit((Object)(object)val))
			{
				errorText.text = "Failed to load prefab";
				((Component)errorText.transform.parent).gameObject.SetActive(true);
			}
			else
			{
				onPick?.Invoke(val, val2, text, text2);
				DialogController.HideTopmost();
			}
		}

		public void Cancel()
		{
			DialogController.HideTopmost();
		}
	}
	public class TextDialogController : MonoBehaviour
	{
		public TMP_Text textComponent;

		public void Ok()
		{
			DialogController.HideTopmost();
		}
	}
}
namespace ItemDisplayPlacementHelper.AxisEditing
{
	public class CircleAxisDrawer : MonoBehaviour
	{
		public Material lineMaterial;

		public Color color;

		[Range(0f, 1000f)]
		public int lineCount = 50;

		public float radius = 1f;

		[Space]
		public Vector3 movementStart;

		public float movementAngle;

		[Range(0f, 1f)]
		public float movementColorAlpha = 0.1f;

		private void OnEnable()
		{
			CameraPostprocessEventHandler.onPostRender = (EventHandler)Delegate.Combine(CameraPostprocessEventHandler.onPostRender, new EventHandler(DrawLine));
		}

		private void OnDisable()
		{
			CameraPostprocessEventHandler.onPostRender = (EventHandler)Delegate.Remove(CameraPostprocessEventHandler.onPostRender, new EventHandler(DrawLine));
		}

		private void DrawLine(object source, EventArgs eventArgs)
		{
			//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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)lineMaterial))
			{
				return;
			}
			lineMaterial.SetPass(0);
			Vector3 val = ((Component)Camera.main).transform.forward;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			val = ((Component)this).transform.forward;
			Vector3 normalized2 = ((Vector3)(ref val)).normalized;
			bool flag = (double)Mathf.Abs(Vector3.Dot(normalized2, normalized)) > 0.98;
			val = (flag ? CalculateOrthogonalVector(normalized2) : Vector3.Cross(normalized2, normalized));
			Vector3 orthogonalVector = ((Vector3)(ref val)).normalized;
			val = Vector3.Cross(normalized2, orthogonalVector);
			Vector3 circleStartVector = ((Vector3)(ref val)).normalized;
			GL.Begin(2);
			GL.Color(color);
			int num = lineCount / (flag ? 1 : 2);
			for (int i = 0; i < num; i++)
			{
				float angle = (float)i / (float)num * MathF.PI * (float)((!flag) ? 1 : 2);
				GL.Vertex(CalculatePointOnCircle(angle));
			}
			GL.Vertex(CalculatePointOnCircle(flag ? 0f : MathF.PI));
			GL.End();
			Vector3 val2 = movementStart;
			val = default(Vector3);
			if (val2 != val)
			{
				val = ((Component)this).transform.rotation * movementStart;
				orthogonalVector = ((Vector3)(ref val)).normalized;
				val = Vector3.Cross(normalized2, orthogonalVector);
				circleStartVector = ((Vector3)(ref val)).normalized;
				GL.Begin(4);
				GL.Color(new Color(color.r, color.g, color.b, movementColorAlpha));
				int num2 = 0;
				float num3 = 0f;
				float num4 = 1f / ((float)lineCount * MathF.PI * 2f);
				float num5 = Mathf.Sign(movementAngle);
				float num6 = Mathf.Clamp(Mathf.Abs(movementAngle), 0f, MathF.PI * 6f);
				if (num3 == num6)
				{
					GL.Vertex(((Component)this).transform.position);
					GL.Vertex(CalculatePointOnCircle(0f));
					GL.Vertex(CalculatePointOnCircle(0f));
				}
				while (num3 < num6)
				{
					GL.Vertex(((Component)this).transform.position);
					num3 = (float)num2 * num4;
					GL.Vertex(CalculatePointOnCircle(num3 * num5));
					num2++;
					num3 = Math.Min((float)num2 * num4, num6);
					GL.Vertex(CalculatePointOnCircle(num3 * num5));
				}
				GL.End();
			}
			Vector3 CalculatePointOnCircle(float num7)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val3 = orthogonalVector * Mathf.Cos(num7) * radius + circleStartVector * Mathf.Sin(num7) * radius;
				val3.x *= ((Component)this).transform.lossyScale.x;
				val3.y *= ((Component)this).transform.lossyScale.y;
				val3.z *= ((Component)this).transform.lossyScale.z;
				return ((Component)this).transform.position + val3;
			}
		}

		private void OnDrawGizmos()
		{
			DrawLine(this, null);
		}

		private Vector3 CalculateOrthogonalVector(Vector3 vector)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if (vector.x != 0f)
			{
				return new Vector3(vector.y, 0f - vector.x, 0f);
			}
			if (vector.y != 0f)
			{
				return new Vector3(0f - vector.y, vector.x, 0f);
			}
			if (vector.z != 0f)
			{
				return new Vector3(0f - vector.z, 0f, vector.x);
			}
			return Vector3.zero;
		}
	}
	public class EditorAxisController : MonoBehaviour
	{
		public float normalScaleCameraDistance = 7.5f;

		public float minScale = 0.001f;

		[SerializeField]
		private GameObject moveAxisObject;

		[SerializeField]
		private GameObject scaleAxisObject;

		[SerializeField]
		private GameObject rotateAxisObject;

		private EditMode editMode;

		public Transform SelectedObject { get; private set; }

		public static EditorAxisController Instance { get; private set; }

		[HideInInspector]
		public Axis SelectedAxis { get; set; }

		[HideInInspector]
		public EditMode EditMode
		{
			get
			{
				return editMode;
			}
			set
			{
				if (editMode != value)
				{
					editMode = value;
					OnEditModeChanged();
				}
			}
		}

		public bool OverrideToLocalSpace { get; private set; }

		public EditSpace ActualEditSpace { get; set; }

		public EditSpace EditSpace
		{
			get
			{
				if (!OverrideToLocalSpace)
				{
					return ActualEditSpace;
				}
				return EditSpace.Local;
			}
		}

		private void Awake()
		{
			Instance = this;
			DisableAxisObjects();
		}

		private void OnDestroy()
		{
			Instance = null;
		}

		public void SetSelectedObject(Transform newObject)
		{
			SelectedObject = newObject;
			OnEditModeChanged();
		}

		private void OnEditModeChanged()
		{
			DisableAxisObjects();
			if (Object.op_Implicit((Object)(object)SelectedObject))
			{
				switch (EditMode)
				{
				case EditMode.Move:
					moveAxisObject.SetActive(true);
					break;
				case EditMode.Scale:
					scaleAxisObject.SetActive(true);
					break;
				case EditMode.Rotate:
					rotateAxisObject.SetActive(true);
					break;
				}
			}
		}

		private void DisableAxisObjects()
		{
			moveAxisObject.SetActive(false);
			scaleAxisObject.SetActive(false);
			rotateAxisObject.SetActive(false);
			OverrideToLocalSpace = EditMode == EditMode.Scale;
		}

		private void LateUpdate()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: 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)
			if (!Object.op_Implicit((Object)(object)SelectedObject))
			{
				return;
			}
			((Component)this).transform.position = ((Component)SelectedObject).transform.position;
			float z = Camera.main.WorldToScreenPoint(((Component)this).transform.position).z;
			if (z < 0f)
			{
				((Component)this).transform.localScale = Vector3.one * minScale;
			}
			else
			{
				float num = z / normalScaleCameraDistance;
				if (num < 1f)
				{
					num = Mathf.Pow(num, 0.85f);
				}
				((Component)this).transform.localScale = Vector3.one * Mathf.Max(minScale, num);
			}
			switch (EditSpace)
			{
			case EditSpace.Global:
				((Component)this).transform.rotation = Quaternion.identity;
				break;
			case EditSpace.Local:
				((Component)this).transform.rotation = ((Component)SelectedObject).transform.rotation;
				break;
			}
		}
	}
	public class LineAxisDrawer : MonoBehaviour
	{
		public Material lineMaterial;

		public Color color;

		public Axis axis;

		private void OnEnable()
		{
			CameraPostprocessEventHandler.onPostRender = (EventHandler)Delegate.Combine(CameraPostprocessEventHandler.onPostRender, new EventHandler(DrawLine));
		}

		private void OnDisable()
		{
			CameraPostprocessEventHandler.onPostRender = (EventHandler)Delegate.Remove(CameraPostprocessEventHandler.onPostRender, new EventHandler(DrawLine));
		}

		private void DrawLine(object source, EventArgs eventArgs)
		{
			//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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)lineMaterial))
			{
				lineMaterial.SetPass(0);
				Vector3 val = Vector3.zero;
				switch (axis)
				{
				case Axis.X:
					val = Vector3.right;
					break;
				case Axis.Y:
					val = Vector3.up;
					break;
				case Axis.Z:
					val = Vector3.forward;
					break;
				}
				GL.PushMatrix();
				GL.MultMatrix(((Component)this).transform.localToWorldMatrix);
				GL.Begin(1);
				GL.Color(color);
				GL.Vertex(Vector3.zero);
				GL.Vertex(val);
				GL.End();
				GL.PopMatrix();
			}
		}

		private void OnDrawGizmos()
		{
			DrawLine(this, null);
		}
	}
	public class MoveObjectAlongAxis : TransformObjectAlongAxis
	{
		protected override void OnMouseDragActive()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)editorAxisController.SelectedObject))
			{
				return;
			}
			Vector3 zero = Vector3.zero;
			switch (axis)
			{
			case Axis.X:
				((Vector3)(ref zero))..ctor(GetMovementMagnitude(), 0f, 0f);
				break;
			case Axis.Y:
				((Vector3)(ref zero))..ctor(0f, GetMovementMagnitude(), 0f);
				break;
			case Axis.Z:
				((Vector3)(ref zero))..ctor(0f, 0f, GetMovementMagnitude());
				break;
			}
			if (!(zero == default(Vector3)))
			{
				switch (editorAxisController.EditSpace)
				{
				case EditSpace.Global:
				{
					Transform selectedObject2 = editorAxisController.SelectedObject;
					selectedObject2.position += zero;
					break;
				}
				case EditSpace.Local:
				{
					Transform selectedObject = editorAxisController.SelectedObject;
					selectedObject.position += editorAxisController.SelectedObject.rotation * zero;
					break;
				}
				}
			}
		}
	}
	public class RotateObjectAlongAxis : TransformObjectAlongAxis
	{
		protected override void OnDisable()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			base.OnDisable();
			if (Object.op_Implicit((Object)(object)circleAxisDrawer))
			{
				circleAxisDrawer.movementStart = default(Vector3);
				circleAxisDrawer.movementAngle = 0f;
			}
		}

		protected override void OnMouseDragActive()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)editorAxisController.SelectedObject))
			{
				return;
			}
			float movementMagnitude = GetMovementMagnitude();
			Vector3 val = Vector3.zero;
			Space val2 = (Space)editorAxisController.EditSpace;
			switch (axis)
			{
			case Axis.X:
				((Vector3)(ref val))..ctor(movementMagnitude, 0f, 0f);
				break;
			case Axis.Y:
				((Vector3)(ref val))..ctor(0f, movementMagnitude, 0f);
				break;
			case Axis.Z:
				((Vector3)(ref val))..ctor(0f, 0f, movementMagnitude);
				break;
			case Axis.CameraPerpendicular:
				val = ((Component)Camera.main).transform.rotation * new Vector3(0f, 0f, movementMagnitude);
				val2 = (Space)0;
				break;
			}
			if (val == default(Vector3))
			{
				return;
			}
			Quaternion rotation = editorAxisController.SelectedObject.rotation;
			editorAxisController.SelectedObject.Rotate(val, val2);
			float num = Quaternion.Angle(rotation, editorAxisController.SelectedObject.rotation) * Mathf.Sign(movementMagnitude) * (MathF.PI / 180f);
			if (!Object.op_Implicit((Object)(object)circleAxisDrawer))
			{
				return;
			}
			switch (editorAxisController.EditSpace)
			{
			case EditSpace.Global:
				circleAxisDrawer.movementAngle += num;
				break;
			case EditSpace.Local:
				if (axis == Axis.CameraPerpendicular)
				{
					circleAxisDrawer.movementAngle += num;
				}
				else
				{
					circleAxisDrawer.movementAngle -= num;
				}
				break;
			}
		}

		protected override void OnMouseDown()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			startedDragOutOfScene = !EditorSceneCameraController.Instance.PointerInside;
			if (!startedDragOutOfScene)
			{
				Vector3 val = Camera.main.WorldToScreenPoint(((Component)this).transform.position);
				RaycastHit val2 = default(RaycastHit);
				Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), ref val2, 10000f, LayerMask.op_Implicit(((LayerIndex)(ref LayerIndex.uiWorldSpace)).mask));
				Vector3 val3 = Vector3.ProjectOnPlane(((Component)this).transform.InverseTransformPoint(((RaycastHit)(ref val2)).point), Vector3.forward);
				Vector3 normalized = ((Vector3)(ref val3)).normalized;
				val3 = ((Component)Camera.main).transform.InverseTransformDirection(((Component)this).transform.TransformDirection(Vector2.op_Implicit(Vector2.Perpendicular(Vector2.op_Implicit(normalized)))));
				normalizedDirection = Vector2.op_Implicit(((Vector3)(ref val3)).normalized);
				startDistanceToObject = val.z;
				lastMousePosition = Input.mousePosition;
				editorAxisController.SelectedAxis = axis;
				startEditSpace = editorAxisController.EditSpace;
				canDrag = true;
				startObjectScale = editorAxisController.SelectedObject.localScale;
				if (Object.op_Implicit((Object)(object)circleAxisDrawer))
				{
					circleAxisDrawer.movementStart = normalized;
				}
			}
		}

		protected override void OnMouseUp()
		{
			//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)
			base.OnMouseUp();
			if (Object.op_Implicit((Object)(object)circleAxisDrawer))
			{
				circleAxisDrawer.movementStart = Vector3.zero;
				circleAxisDrawer.movementAngle = 0f;
			}
		}

		protected override float GetMovementMagnitude()
		{
			//IL_0000: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Input.mousePosition - lastMousePosition;
			if (((Vector3)(ref val)).magnitude == 0f)
			{
				return 0f;
			}
			return Vector2.Dot(Vector2.op_Implicit(val), normalizedDirection) * 57.29578f * 0.02f;
		}
	}
	public class ScaleObjectAlongAllAxis : TransformObjectAlongAxis
	{
		protected override void OnMouseDragActive()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)editorAxisController.SelectedObject))
			{
				float movementMagnitude = GetMovementMagnitude();
				if (movementMagnitude != 0f)
				{
					Transform selectedObject = editorAxisController.SelectedObject;
					selectedObject.localScale += Vector3.Scale(new Vector3(movementMagnitude, movementMagnitude, movementMagnitude), startObjectScale);
				}
			}
		}

		protected override float GetMovementMagnitude()
		{
			//IL_0000: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Input.mousePosition - lastMousePosition;
			if (((Vector3)(ref val)).magnitude == 0f)
			{
				return 0f;
			}
			return Vector2.Dot(Vector2.op_Implicit(val), Vector2.one) * startDistanceToObject * 0.002f;
		}
	}
	public class ScaleObjectAlongAxis : TransformObjectAlongAxis
	{
		protected override void OnMouseDragActive()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)editorAxisController.SelectedObject))
			{
				Vector3 zero = Vector3.zero;
				switch (axis)
				{
				case Axis.X:
					((Vector3)(ref zero))..ctor(GetMovementMagnitude(), 0f, 0f);
					break;
				case Axis.Y:
					((Vector3)(ref zero))..ctor(0f, GetMovementMagnitude(), 0f);
					break;
				case Axis.Z:
					((Vector3)(ref zero))..ctor(0f, 0f, GetMovementMagnitude());
					break;
				}
				if (!(zero == default(Vector3)))
				{
					Transform selectedObject = editorAxisController.SelectedObject;
					selectedObject.localScale += Vector3.Scale(zero, startObjectScale);
				}
			}
		}
	}
	public abstract class TransformObjectAlongAxis : MonoBehaviour
	{
		public EditorAxisController editorAxisController;

		public Axis axis;

		public Color hoverColor;

		public Color initialColor;

		public Color inactiveColor;

		protected Vector3 lastMousePosition;

		protected CircleAxisDrawer circleAxisDrawer;

		protected LineAxisDrawer lineAxisDrawer;

		protected Renderer renderer;

		protected bool mouseHover;

		protected bool canDrag;

		protected EditSpace startEditSpace;

		protected bool editSpaceChanged;

		protected bool startedDragOutOfScene;

		protected float startDistanceToObject;

		protected Vector2 normalizedDirection;

		protected Vector3 startObjectScale;

		protected const float magnitudeMultiplier = 0.002f;

		protected virtual void Awake()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			renderer = ((Component)this).GetComponentInChildren<Renderer>();
			if (Object.op_Implicit((Object)(object)renderer))
			{
				initialColor = renderer.material.color;
			}
			lineAxisDrawer = ((Component)this).GetComponent<LineAxisDrawer>();
			if (Object.op_Implicit((Object)(object)lineAxisDrawer))
			{
				lineAxisDrawer.color = initialColor;
				lineAxisDrawer.axis = axis;
			}
			circleAxisDrawer = ((Component)this).GetComponent<CircleAxisDrawer>();
			if (Object.op_Implicit((Object)(object)circleAxisDrawer))
			{
				circleAxisDrawer.color = initialColor;
			}
		}

		protected virtual void OnDisable()
		{
			canDrag = false;
			startedDragOutOfScene = false;
			mouseHover = false;
			editorAxisController.SelectedAxis = Axis.None;
			editSpaceChanged = false;
		}

		protected virtual void Update()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			Color updateColor = GetUpdateColor();
			if (Object.op_Implicit((Object)(object)renderer))
			{
				renderer.material.color = updateColor;
			}
			if (Object.op_Implicit((Object)(object)lineAxisDrawer))
			{
				lineAxisDrawer.color = updateColor;
			}
			if (Object.op_Implicit((Object)(object)circleAxisDrawer))
			{
				circleAxisDrawer.color = updateColor;
			}
		}

		private Color GetUpdateColor()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (editorAxisController.SelectedAxis == Axis.None)
			{
				if (mouseHover && EditorSceneCameraController.Instance.PointerInside)
				{
					return hoverColor;
				}
				return initialColor;
			}
			if (editorAxisController.SelectedAxis == axis)
			{
				return hoverColor;
			}
			return inactiveColor;
		}

		protected virtual void OnMouseDown()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			startedDragOutOfScene = !EditorSceneCameraController.Instance.PointerInside;
			if (!startedDragOutOfScene)
			{
				Vector3 val = Vector3.zero;
				switch (axis)
				{
				case Axis.X:
					val = ((Component)this).transform.right;
					break;
				case Axis.Y:
					val = ((Component)this).transform.up;
					break;
				case Axis.Z:
					val = ((Component)this).transform.forward;
					break;
				}
				Vector3 val2 = Camera.main.WorldToScreenPoint(((Component)this).transform.position + Vector3.ClampMagnitude(val, 0.001f));
				Vector3 val3 = Camera.main.WorldToScreenPoint(((Component)this).transform.position);
				Vector3 val4 = val2 - val3;
				normalizedDirection = Vector2.op_Implicit(((Vector3)(ref val4)).normalized);
				startDistanceToObject = val3.z;
				lastMousePosition = Input.mousePosition;
				editorAxisController.SelectedAxis = axis;
				startEditSpace = editorAxisController.EditSpace;
				canDrag = true;
				startObjectScale = editorAxisController.SelectedObject.localScale;
			}
		}

		protected virtual void OnMouseUp()
		{
			editorAxisController.SelectedAxis = Axis.None;
			editSpaceChanged = false;
			startedDragOutOfScene = false;
			canDrag = false;
		}

		protected virtual void OnMouseEnter()
		{
			mouseHover = true;
		}

		protected virtual void OnMouseExit()
		{
			mouseHover = false;
		}

		protected virtual void OnMouseDrag()
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if (!canDrag || startedDragOutOfScene || editSpaceChanged)
			{
				return;
			}
			if (startEditSpace != editorAxisController.EditSpace)
			{
				editorAxisController.SelectedAxis = Axis.None;
				editSpaceChanged = true;
				if (Object.op_Implicit((Object)(object)circleAxisDrawer))
				{
					circleAxisDrawer.movementStart = default(Vector3);
					circleAxisDrawer.movementAngle = 0f;
				}
			}
			else
			{
				OnMouseDragActive();
				lastMousePosition = Input.mousePosition;
			}
		}

		protected virtual void OnMouseDragActive()
		{
		}

		protected virtual float GetMovementMagnitude()
		{
			//IL_0000: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Input.mousePosition - lastMousePosition;
			if (((Vector3)(ref val)).magnitude == 0f)
			{
				return 0f;
			}
			return Vector2.Dot(Vector2.op_Implicit(val), normalizedDirection) * startDistanceToObject * 0.002f;
		}
	}
}
namespace ItemDisplayPlacementHelper.AnimatorEditing
{
	public class AnimatorPanelController : MonoBehaviour
	{
		private CharacterModel currentModel;

		private Animator currentAnimator;

		public TMP_Dropdown layerDropdown;

		public TMP_InputField stateInput;

		public Button playButton;

		[Space]
		public Toggle animatorToggle;

		private void Awake()
		{
			ModelPicker.OnModelChanged += OnModelChanged;
			ModelPicker.OnModelWillChange += OnModelWillChange;
		}

		private void OnDestroy()
		{
			ModelPicker.OnModelChanged -= OnModelChanged;
			ModelPicker.OnModelWillChange -= OnModelWillChange;
		}

		private void Update()
		{
			((Selectable)layerDropdown).interactable = Object.op_Implicit((Object)(object)currentAnimator);
			((Selectable)stateInput).interactable = Object.op_Implicit((Object)(object)currentAnimator);
			((Selectable)playButton).interactable = Object.op_Implicit((Object)(object)currentAnimator);
			((Selectable)animatorToggle).interactable = Object.op_Implicit((Object)(object)currentAnimator);
		}

		private void OnModelWillChange()
		{
			layerDropdown.options.Clear();
			currentAnimator = null;
		}

		private void OnModelChanged(CharacterModel model)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			currentModel = model;
			if (Object.op_Implicit((Object)(object)currentModel))
			{
				currentAnimator = ((Component)currentModel).GetComponent<Animator>();
			}
			if (Object.op_Implicit((Object)(object)currentAnimator))
			{
				((Behaviour)currentAnimator).enabled = animatorToggle.isOn;
				List<OptionData> list = new List<OptionData>();
				for (int i = 0; i < currentAnimator.layerCount; i++)
				{
					list.Add(new OptionData(currentAnimator.GetLayerName(i)));
				}
				layerDropdown.AddOptions(list);
			}
		}

		public void PlayAnimation()
		{
			if (Object.op_Implicit((Object)(object)currentAnimator))
			{
				currentAnimator.Play(stateInput.text, layerDropdown.value);
			}
		}

		public void ToggleAnimator(bool enabled)
		{
			if (Object.op_Implicit((Object)(object)currentAnimator))
			{
				((Behaviour)currentAnimator).enabled = enabled;
			}
		}
	}
	public class AnimatorParameterField : MonoBehaviour
	{
		[HideInInspector]
		public Animator animator;

		[HideInInspector]
		public AnimatorControllerParameter parameter;

		public Toggle toggle;

		public TMP_InputField inputField;

		public TMP_Text label;

		private bool currentBoolValue;

		private float currentFloatValue;

		private int currentIntValue;

		private void Start()
		{
			label.text = parameter.name;
		}

		private void LateUpdate()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected I4, but got Unknown
			AnimatorControllerParameterType type = parameter.type;
			switch (type - 1)
			{
			case 3:
			{
				bool flag = animator.GetBool(parameter.name);
				if (currentBoolValue != flag)
				{
					currentBoolValue = flag;
					toggle.isOn = currentBoolValue;
				}
				break;
			}
			case 2:
			{
				int integer = animator.GetInteger(parameter.name);
				if (currentIntValue != integer)
				{
					currentIntValue = integer;
					inputField.text = currentIntValue.ToString();
				}
				break;
			}
			case 0:
			{
				float num = animator.GetFloat(parameter.name);
				if (currentFloatValue != num)
				{
					currentFloatValue = num;
					inputField.text = currentFloatValue.ToString(CultureInfo.InvariantCulture);
				}
				break;
			}
			case 1:
				break;
			}
		}

		public void OnInputValueChanged(string value)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			AnimatorControllerParameterType type = parameter.type;
			float result2;
			if ((int)type != 1)
			{
				if ((int)type == 3 && int.TryParse(value, out var result))
				{
					currentIntValue = result;
					animator.SetInteger(parameter.name, result);
				}
			}
			else if (float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out result2))
			{
				currentFloatValue = result2;
				animator.SetFloat(parameter.name, result2);
			}
		}

		public void OnInputEndEdit(string value)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			AnimatorControllerParameterType type = parameter.type;
			float result2;
			if ((int)type != 1)
			{
				if ((int)type == 3 && !int.TryParse(value, out var _))
				{
					inputField.text = parameter.defaultInt.ToString();
				}
			}
			else if (!float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out result2))
			{
				inputField.text = parameter.defaultFloat.ToString(CultureInfo.InvariantCulture);
			}
		}

		public void OnToggle(bool value)
		{
			currentBoolValue = value;
			animator.SetBool(parameter.name, currentBoolValue);
		}
	}
}