using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Sockets;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using EnhancedValheimVRM.Sharing;
using HarmonyLib;
using UniGLTF;
using UniGLTF.Extensions.VRMC_vrm;
using UniGLTF.SpringBoneJobs;
using UniGLTF.SpringBoneJobs.Blittables;
using UniGLTF.Utils;
using UniVRM10;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.LowLevel;
using UnityEngine.PlayerLoop;
using UnityEngine.SceneManagement;
using VRM;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("EnhancedValheimVRM")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("EnhancedValheimVRM")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("56266ABF-B3F1-44F5-8790-D269FE536067")]
[assembly: AssemblyFileVersion("1.4.1")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = "")]
[assembly: AssemblyVersion("1.4.1.0")]
namespace EnhancedValheimVRM
{
	public sealed class OutfitDefinition
	{
		public string Name;

		public bool IsDefault;

		public readonly Dictionary<string, bool> Meshes = new Dictionary<string, bool>(StringComparer.Ordinal);

		public readonly Dictionary<string, float> Blendshapes = new Dictionary<string, float>(StringComparer.Ordinal);
	}
	public sealed class OutfitConfig
	{
		public readonly List<OutfitDefinition> Outfits = new List<OutfitDefinition>();

		public readonly HashSet<string> KeepBlendshapes = new HashSet<string>(StringComparer.Ordinal);

		public const string KeepSection = "Blendshapes";

		public OutfitDefinition Default => Outfits.Find((OutfitDefinition outfit) => outfit.IsDefault);

		public OutfitDefinition Find(string name)
		{
			return Outfits.Find((OutfitDefinition outfit) => string.Equals(outfit.Name, name, StringComparison.OrdinalIgnoreCase));
		}

		public static OutfitConfig Parse(string text)
		{
			if (Encoding.UTF8.GetByteCount(text) > 131072)
			{
				throw new InvalidDataException("Outfit file exceeds 128 KiB.");
			}
			OutfitConfig outfitConfig = new OutfitConfig();
			OutfitDefinition outfitDefinition = null;
			bool flag = false;
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			int num = 0;
			using (StringReader stringReader = new StringReader(text))
			{
				string text2;
				while ((text2 = stringReader.ReadLine()) != null)
				{
					num++;
					string text3 = text2.Trim();
					if (text3.Length == 0 || text3.StartsWith("#") || text3.StartsWith("//") || text3.StartsWith(";"))
					{
						continue;
					}
					if (text3.StartsWith("[") && text3.EndsWith("]"))
					{
						string text4 = text3.Substring(1, text3.Length - 2).Trim();
						if (text4.Equals("Blendshapes", StringComparison.OrdinalIgnoreCase))
						{
							outfitDefinition = null;
							flag = true;
							continue;
						}
						flag = false;
						SharingWire.ValidateOutfitName(text4);
						if (outfitConfig.Find(text4) != null || outfitConfig.Outfits.Count >= 64)
						{
							throw new InvalidDataException("Duplicate outfit name or too many outfits.");
						}
						outfitDefinition = new OutfitDefinition
						{
							Name = text4
						};
						outfitConfig.Outfits.Add(outfitDefinition);
						hashSet.Clear();
						continue;
					}
					int num2 = text3.IndexOf('=');
					if (flag)
					{
						if (num2 >= 0 || outfitConfig.KeepBlendshapes.Count >= 1024)
						{
							throw new InvalidDataException("Invalid blendshape entry at line " + num);
						}
						outfitConfig.KeepBlendshapes.Add(text3);
						continue;
					}
					if (outfitDefinition == null || num2 < 1)
					{
						throw new InvalidDataException("Invalid outfit entry at line " + num);
					}
					string text5 = text3.Substring(0, num2).Trim();
					string text6 = text3.Substring(num2 + 1).Trim();
					if (!hashSet.Add(text5.Equals("Default", StringComparison.OrdinalIgnoreCase) ? "Default" : text5))
					{
						throw new InvalidDataException("Duplicate outfit entry at line " + num);
					}
					if (text5.Equals("Default", StringComparison.OrdinalIgnoreCase) && bool.TryParse(text6, out var result))
					{
						outfitDefinition.IsDefault = result;
						continue;
					}
					if (text5.StartsWith("mesh:") && text5.Length > 5 && bool.TryParse(text6, out var result2))
					{
						outfitDefinition.Meshes.Add(text5.Substring(5), result2);
						continue;
					}
					if (text5.StartsWith("blendshape:") && text5.Substring(11).IndexOf(':') > 0 && !text5.EndsWith(":") && float.TryParse(text6, NumberStyles.Float, CultureInfo.InvariantCulture, out var result3) && !float.IsNaN(result3) && result3 >= 0f && result3 <= 100f)
					{
						outfitDefinition.Blendshapes.Add(text5.Substring(11), result3);
						continue;
					}
					throw new InvalidDataException("Invalid outfit entry at line " + num + ": " + text5);
				}
			}
			if (outfitConfig.Outfits.Count > 0 && outfitConfig.Outfits.Count((OutfitDefinition outfit) => outfit.IsDefault) != 1)
			{
				throw new InvalidDataException("Set Default=True in exactly one outfit section.");
			}
			if (outfitConfig.Outfits.Count == 0 && outfitConfig.KeepBlendshapes.Count == 0)
			{
				throw new InvalidDataException("Set Default=True in exactly one outfit section.");
			}
			return outfitConfig;
		}
	}
	[DefaultExecutionOrder(10000)]
	public sealed class OutfitController : MonoBehaviour
	{
		private Player _player;

		private string _path;

		private OutfitConfig _config;

		private bool _staging;

		private readonly Dictionary<Renderer, bool> _originalVisibility = new Dictionary<Renderer, bool>();

		private readonly Dictionary<Renderer, bool> _originalEnabled = new Dictionary<Renderer, bool>();

		private readonly HashSet<GameObject> _activatedNodes = new HashSet<GameObject>();

		private readonly Dictionary<SkinnedMeshRenderer, float[]> _originalWeights = new Dictionary<SkinnedMeshRenderer, float[]>();

		private readonly Dictionary<Renderer, bool> _visibility = new Dictionary<Renderer, bool>();

		private readonly Dictionary<SkinnedMeshRenderer, Dictionary<int, float>> _weights = new Dictionary<SkinnedMeshRenderer, Dictionary<int, float>>();

		private bool _reloading;

		public string CurrentName { get; private set; } = "";

		public string SourceText { get; private set; } = "";

		public IEnumerable<string> Names => _config?.Outfits.Select((OutfitDefinition outfit) => outfit.Name) ?? Enumerable.Empty<string>();

		internal void SetStaging(bool staging)
		{
			_staging = staging;
			foreach (KeyValuePair<Renderer, bool> item in _originalVisibility)
			{
				if (!((Object)(object)item.Key != (Object)null))
				{
					continue;
				}
				item.Key.forceRenderingOff = item.Value;
				if (item.Value)
				{
					continue;
				}
				item.Key.enabled = true;
				Transform val = ((Component)item.Key).transform;
				while ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)((Component)this).transform)
				{
					if (!((Component)val).gameObject.activeSelf)
					{
						_activatedNodes.Add(((Component)val).gameObject);
						((Component)val).gameObject.SetActive(true);
					}
					val = val.parent;
				}
			}
			ApplyValues();
		}

		internal void SetupPrepared(Player player, string path, string text, bool isShared, OutfitConfig prepared)
		{
			_player = player;
			_path = (isShared ? null : path);
			Renderer[] componentsInChildren = ((Component)this).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				_originalVisibility[val] = val.forceRenderingOff;
				_originalEnabled[val] = val.enabled;
				SkinnedMeshRenderer val2 = (SkinnedMeshRenderer)(object)((val is SkinnedMeshRenderer) ? val : null);
				if (val2 != null && (Object)(object)val2.sharedMesh != (Object)null)
				{
					float[] array = new float[val2.sharedMesh.blendShapeCount];
					for (int j = 0; j < array.Length; j++)
					{
						array[j] = val2.GetBlendShapeWeight(j);
					}
					_originalWeights[val2] = array;
				}
			}
			if (string.IsNullOrWhiteSpace(text))
			{
				text = DefaultTemplate();
				prepared = null;
			}
			if (prepared == null)
			{
				LoadText(text);
			}
			else
			{
				ApplyConfig(text, prepared);
			}
		}

		private bool LoadText(string text)
		{
			try
			{
				OutfitConfig config = OutfitConfig.Parse(text);
				ApplyConfig(text, config);
				return true;
			}
			catch (Exception ex) when (ex is InvalidDataException || ex is ArgumentException)
			{
				Logger.LogWarning("Outfit file: " + ex.Message);
				return false;
			}
		}

		private void ApplyConfig(string text, OutfitConfig config)
		{
			Restore();
			_config = config;
			SourceText = text;
			OutfitDefinition outfitDefinition = config.Find(CurrentName) ?? config.Default;
			if (outfitDefinition != null)
			{
				Apply(outfitDefinition.Name);
			}
		}

		public string Reload()
		{
			if (_path == null)
			{
				return "Shared outfit definitions come from the avatar owner.";
			}
			if (_reloading)
			{
				return "Outfit reload is already in progress.";
			}
			((MonoBehaviour)this).StartCoroutine(ReloadAsync());
			return "Reading outfit file in the background.";
		}

		private IEnumerator ReloadAsync()
		{
			_reloading = true;
			string path = _path;
			Task<Tuple<string, OutfitConfig>> read = Task.Run(delegate
			{
				if (new FileInfo(path).Length > 131072)
				{
					throw new InvalidDataException("Outfit file exceeds 128 KiB.");
				}
				string text = File.ReadAllText(path);
				return Tuple.Create(text, OutfitConfig.Parse(text));
			});
			try
			{
				while (!read.IsCompleted)
				{
					yield return null;
				}
				if (read.IsFaulted)
				{
					Logger.LogWarning("Outfit reload failed; previous outfits retained: " + read.Exception.GetBaseException().Message);
					yield break;
				}
				Tuple<string, OutfitConfig> result = read.GetAwaiter().GetResult();
				ApplyConfig(result.Item1, result.Item2);
				FileTransferController.RefreshUpload();
				Logger.Log("Reloaded outfits from " + path);
			}
			finally
			{
				_reloading = false;
			}
		}

		public bool Apply(string name)
		{
			OutfitDefinition outfitDefinition = _config?.Find(name);
			if (outfitDefinition == null)
			{
				return false;
			}
			Restore();
			foreach (KeyValuePair<string, bool> entry in outfitDefinition.Meshes)
			{
				Renderer[] array = _originalVisibility.Keys.Where((Renderer renderer) => (Object)(object)renderer != (Object)null && ((Object)renderer).name == entry.Key).ToArray();
				if (array.Length == 0)
				{
					Logger.LogOnce("outfit-mesh:" + entry.Key, "Outfit mesh not found: " + entry.Key);
				}
				Renderer[] array2 = array;
				foreach (Renderer key in array2)
				{
					_visibility[key] = !entry.Value;
				}
			}
			foreach (KeyValuePair<string, float> blendshape in outfitDefinition.Blendshapes)
			{
				int num2 = blendshape.Key.IndexOf(':');
				string meshName = blendshape.Key.Substring(0, num2);
				string text = blendshape.Key.Substring(num2 + 1);
				bool flag = false;
				foreach (SkinnedMeshRenderer item in _originalWeights.Keys.Where((SkinnedMeshRenderer skin) => (Object)(object)skin != (Object)null && ((Object)skin).name == meshName))
				{
					int blendShapeIndex = item.sharedMesh.GetBlendShapeIndex(text);
					if (blendShapeIndex >= 0)
					{
						flag = true;
						if (!_weights.TryGetValue(item, out var value))
						{
							_weights.Add(item, value = new Dictionary<int, float>());
						}
						value[blendShapeIndex] = blendshape.Value;
					}
				}
				if (!flag)
				{
					Logger.LogOnce("outfit-shape:" + blendshape.Key, "Outfit blendshape not found: " + blendshape.Key);
				}
			}
			CurrentName = outfitDefinition.Name;
			ApplyValues();
			OutfitRpc.LocalChanged(_player, this);
			return true;
		}

		private void ApplyValues()
		{
			foreach (KeyValuePair<Renderer, bool> item in _visibility)
			{
				if (!((Object)(object)item.Key != (Object)null))
				{
					continue;
				}
				item.Key.forceRenderingOff = item.Value;
				if (item.Value)
				{
					continue;
				}
				item.Key.enabled = true;
				Transform val = ((Component)item.Key).transform;
				while ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)((Component)this).transform)
				{
					if (!((Component)val).gameObject.activeSelf)
					{
						_activatedNodes.Add(((Component)val).gameObject);
						((Component)val).gameObject.SetActive(true);
					}
					val = val.parent;
				}
			}
			foreach (KeyValuePair<SkinnedMeshRenderer, Dictionary<int, float>> weight in _weights)
			{
				if (!((Object)(object)weight.Key != (Object)null))
				{
					continue;
				}
				foreach (KeyValuePair<int, float> item2 in weight.Value)
				{
					weight.Key.SetBlendShapeWeight(item2.Key, item2.Value);
				}
			}
			if (!_staging)
			{
				return;
			}
			foreach (Renderer key in _originalVisibility.Keys)
			{
				if ((Object)(object)key != (Object)null)
				{
					key.forceRenderingOff = true;
				}
			}
		}

		private void Restore()
		{
			foreach (KeyValuePair<Renderer, bool> item in _visibility)
			{
				if ((Object)(object)item.Key != (Object)null)
				{
					item.Key.forceRenderingOff = _originalVisibility[item.Key];
					item.Key.enabled = _originalEnabled[item.Key];
				}
			}
			foreach (KeyValuePair<SkinnedMeshRenderer, Dictionary<int, float>> weight in _weights)
			{
				if (!((Object)(object)weight.Key != (Object)null))
				{
					continue;
				}
				foreach (KeyValuePair<int, float> item2 in weight.Value)
				{
					weight.Key.SetBlendShapeWeight(item2.Key, _originalWeights[weight.Key][item2.Key]);
				}
			}
			foreach (GameObject activatedNode in _activatedNodes)
			{
				if ((Object)(object)activatedNode != (Object)null)
				{
					activatedNode.SetActive(false);
				}
			}
			_activatedNodes.Clear();
			_visibility.Clear();
			_weights.Clear();
		}

		private string DefaultTemplate()
		{
			StringBuilder stringBuilder = new StringBuilder("# Named outfits; exactly one section has Default=True.\n[default]\nDefault=True\n");
			foreach (string item in (from r in _originalVisibility.Keys
				where (Object)(object)r != (Object)null
				select ((Object)r).name).Distinct())
			{
				stringBuilder.Append("mesh:").Append(item).Append("=True\n");
			}
			return stringBuilder.ToString();
		}

		public string Generate()
		{
			if (_path == null)
			{
				return "Generate outfits on the avatar owner's client.";
			}
			string path = _path;
			string text = DefaultTemplate();
			Task.Run(delegate
			{
				try
				{
					using (FileStream stream = new FileStream(path, FileMode.CreateNew, FileAccess.Write, FileShare.Read))
					{
						using StreamWriter streamWriter = new StreamWriter(stream);
						streamWriter.Write(text);
					}
					Logger.Log("Created default outfit: " + path + ". Use /vrm outfit reload to load it.");
				}
				catch (IOException ex)
				{
					Logger.LogWarning(File.Exists(path) ? "Outfit file already exists; left unchanged." : ("Cannot generate outfit: " + ex.Message));
				}
			});
			return "Creating default outfit file if none exists.";
		}

		public string GenerateBlendShapeList()
		{
			if (_path == null)
			{
				return "Generate the blendshape list on the avatar owner's client.";
			}
			List<string> list = new List<string>();
			foreach (SkinnedMeshRenderer key in _originalWeights.Keys)
			{
				if ((Object)(object)key == (Object)null || (Object)(object)key.sharedMesh == (Object)null)
				{
					continue;
				}
				for (int i = 0; i < key.sharedMesh.blendShapeCount; i++)
				{
					string blendShapeName = key.sharedMesh.GetBlendShapeName(i);
					if (!list.Contains(blendShapeName))
					{
						list.Add(blendShapeName);
					}
				}
			}
			if (list.Count == 0)
			{
				return "This avatar has no blendshapes.";
			}
			StringBuilder stringBuilder = new StringBuilder("\n[Blendshapes]\n");
			stringBuilder.Append("# every blendshape this avatar has. only the ones the vrm expressions or this file use get loaded,\n");
			stringBuilder.Append("# remove the # in front of a name to keep it loaded\n");
			foreach (string item in list)
			{
				stringBuilder.Append('#').Append(item).Append('\n');
			}
			string path = _path;
			string section = stringBuilder.ToString();
			Task.Run(delegate
			{
				try
				{
					if (File.Exists(path) && File.ReadAllText(path).IndexOf("[Blendshapes]", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						Logger.LogWarning("The outfit file already has a [Blendshapes] section; left unchanged.");
					}
					else
					{
						File.AppendAllText(path, section);
						Logger.Log("Blendshape list written to " + path + ". Use /vrm outfit reload after editing it.");
					}
				}
				catch (IOException ex)
				{
					Logger.LogWarning("Cannot write the blendshape list: " + ex.Message);
				}
			});
			return "Writing " + list.Count + " blendshape names to the outfit file.";
		}

		internal float OriginalWeight(SkinnedMeshRenderer skin, int index)
		{
			if (!_originalWeights.TryGetValue(skin, out var value) || index < 0 || index >= value.Length)
			{
				return 0f;
			}
			return value[index];
		}

		public bool Toggle(string name)
		{
			Renderer val = ((IEnumerable<Renderer>)_originalVisibility.Keys).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => (Object)(object)r != (Object)null && ((Object)r).name == name));
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			bool value;
			bool flag = (_visibility.TryGetValue(val, out value) ? value : (val.forceRenderingOff || !val.enabled || !((Component)val).gameObject.activeInHierarchy));
			return Override(name, blend: false, flag ? 1 : 0, publish: true);
		}

		public bool Override(string name, bool blend, float value, bool publish = false)
		{
			if (!SharingWire.IsValidOverride(name, blend, value))
			{
				return false;
			}
			bool flag = false;
			if (!blend)
			{
				foreach (Renderer item in _originalVisibility.Keys.Where((Renderer r) => (Object)(object)r != (Object)null && ((Object)r).name == name))
				{
					_visibility[item] = value == 0f;
					flag = true;
				}
			}
			else
			{
				foreach (SkinnedMeshRenderer item2 in _originalWeights.Keys.Where((SkinnedMeshRenderer r) => (Object)(object)r != (Object)null))
				{
					int blendShapeIndex = item2.sharedMesh.GetBlendShapeIndex(name);
					if (blendShapeIndex >= 0)
					{
						if (!_weights.TryGetValue(item2, out var value2))
						{
							value2 = (_weights[item2] = new Dictionary<int, float>());
						}
						value2[blendShapeIndex] = value;
						flag = true;
					}
				}
			}
			if (!flag)
			{
				return false;
			}
			ApplyValues();
			if (publish && (Object)(object)_player == (Object)(object)Player.m_localPlayer)
			{
				SharingRpc.SetOverride(_player.GetPlayerID(), name, blend, value);
			}
			return true;
		}

		private void LateUpdate()
		{
			foreach (KeyValuePair<SkinnedMeshRenderer, Dictionary<int, float>> weight in _weights)
			{
				if (!((Object)(object)weight.Key != (Object)null))
				{
					continue;
				}
				foreach (KeyValuePair<int, float> item in weight.Value)
				{
					weight.Key.SetBlendShapeWeight(item.Key, item.Value);
				}
			}
		}

		private void OnDestroy()
		{
			Restore();
		}
	}
	internal static class OutfitRpc
	{
		internal static void ClientReady()
		{
			Player localPlayer = Player.m_localPlayer;
			VrmInstance vrmInstance = (((Object)(object)localPlayer != (Object)null) ? localPlayer.GetVrmInstance() : null);
			object obj;
			if (vrmInstance == null)
			{
				obj = null;
			}
			else
			{
				GameObject gameObject = vrmInstance.GetGameObject();
				obj = ((gameObject != null) ? gameObject.GetComponent<OutfitController>() : null);
			}
			OutfitController outfitController = (OutfitController)obj;
			if (vrmInstance != null && vrmInstance.IsDisplayed && !vrmInstance.IsCorpse && !((Object)(object)outfitController == (Object)null) && !string.IsNullOrEmpty(outfitController.CurrentName))
			{
				SharingRpc.SetOutfit(localPlayer.GetPlayerID(), outfitController.CurrentName);
			}
		}

		internal static void LocalChanged(Player player, OutfitController outfits)
		{
			if ((Object)(object)player != (Object)null && (Object)(object)player == (Object)(object)Player.m_localPlayer)
			{
				VrmInstance vrmInstance = player.GetVrmInstance();
				object obj;
				if (vrmInstance == null)
				{
					obj = null;
				}
				else
				{
					GameObject gameObject = vrmInstance.GetGameObject();
					obj = ((gameObject != null) ? gameObject.GetComponent<OutfitController>() : null);
				}
				if ((Object)obj == (Object)(object)outfits)
				{
					SharingRpc.SelectOutfit(player.GetPlayerID(), outfits.CurrentName);
				}
			}
		}

		internal static void AvatarReady(Player player)
		{
			if ((Object)(object)player == (Object)(object)Player.m_localPlayer)
			{
				ClientReady();
			}
			else
			{
				ApplyPending(player);
			}
		}

		internal static void SelectionReceived(long id)
		{
			foreach (Player allPlayer in Player.GetAllPlayers())
			{
				if ((Object)(object)allPlayer != (Object)null && (Object)(object)allPlayer != (Object)(object)Player.m_localPlayer && allPlayer.GetPlayerID() == id)
				{
					ApplyPending(allPlayer);
				}
			}
		}

		private static void ApplyPending(Player player)
		{
			if ((Object)(object)player == (Object)null || ((Character)player).IsDead())
			{
				return;
			}
			string outfit = SharingRpc.GetOutfit(player.GetPlayerID());
			VrmInstance vrmInstance = player.GetVrmInstance();
			if (vrmInstance == null || !vrmInstance.IsDisplayed || vrmInstance.IsCorpse)
			{
				return;
			}
			GameObject gameObject = vrmInstance.GetGameObject();
			OutfitController outfits = ((gameObject != null) ? gameObject.GetComponent<OutfitController>() : null);
			if (!((Object)(object)outfits == (Object)null))
			{
				outfits.Apply(outfit ?? outfits.CurrentName);
				SharingRpc.ApplyOverrides(player.GetPlayerID(), delegate(string part, bool blend, float value)
				{
					outfits.Override(part, blend, value);
				});
			}
		}
	}
	public class BoneGizmos : MonoBehaviour
	{
		private sealed class SocketGizmo
		{
			public Transform Bone;

			public string Label;

			public readonly List<LineRenderer> Axes = new List<LineRenderer>();
		}

		private readonly List<SocketGizmo> _gizmos = new List<SocketGizmo>();

		private readonly HashSet<Transform> _equipmentSockets = new HashSet<Transform>();

		private GUIStyle _labelStyle;

		public void Setup(Player player, VrmInstance vrmInstance, bool playerGizmoEnabled = false, bool vrmGizmoEnabled = false)
		{
			ClearGizmos();
			_equipmentSockets.Clear();
			if (player.TryGetField<Player, VisEquipment>("m_visEquipment", out var result) && (Object)(object)result != (Object)null)
			{
				Transform[] array = (Transform[])(object)new Transform[9] { result.m_leftHand, result.m_rightHand, result.m_helmet, result.m_backShield, result.m_backMelee, result.m_backTwohandedMelee, result.m_backBow, result.m_backTool, result.m_backAtgeir };
				foreach (Transform val in array)
				{
					if ((Object)(object)val != (Object)null)
					{
						_equipmentSockets.Add(val);
					}
				}
			}
			Shader val2 = Shader.Find("Unlit/Color");
			if (!((Object)(object)val2 == (Object)null))
			{
				if (playerGizmoEnabled)
				{
					AddSockets(player.GetField<Player, Animator>("m_animator"), "Player", val2);
				}
				if (vrmGizmoEnabled)
				{
					AddSockets(vrmInstance.GetVrmGoAnimator(), "VRM", val2);
				}
				UpdateAxes();
			}
		}

		private void AddSockets(Animator animator, string source, Shader shader)
		{
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: 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_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Expected O, but got Unknown
			if ((Object)(object)animator == (Object)null)
			{
				return;
			}
			Transform val = BoneLookup.Get(animator, (HumanBodyBones)15);
			Transform val2 = BoneLookup.Get(animator, (HumanBodyBones)16);
			Transform[] componentsInChildren = ((Component)animator).GetComponentsInChildren<Transform>(true);
			foreach (Transform bone in componentsInChildren)
			{
				bool flag = (Object)(object)bone == (Object)(object)val || (Object)(object)bone == (Object)(object)val2;
				if ((flag || _equipmentSockets.Contains(bone) || ((Object)bone).name.IndexOf("_attach", StringComparison.OrdinalIgnoreCase) >= 0) && !_gizmos.Exists((SocketGizmo existing) => (Object)(object)existing.Bone == (Object)(object)bone))
				{
					SocketGizmo socketGizmo = new SocketGizmo
					{
						Bone = bone,
						Label = source + " / " + ((Object)bone).name + (flag ? " (forearm bone)" : "")
					};
					Color[] array = (Color[])(object)new Color[3]
					{
						Color.red,
						Color.green,
						Color.blue
					};
					foreach (Color val3 in array)
					{
						LineRenderer val4 = new GameObject("BoneGizmoLine").AddComponent<LineRenderer>();
						((Component)val4).transform.SetParent(bone, false);
						Color startColor = (val4.endColor = val3);
						val4.startColor = startColor;
						float startWidth = (val4.endWidth = 0.005f);
						val4.startWidth = startWidth;
						val4.positionCount = 2;
						val4.useWorldSpace = false;
						((Renderer)val4).sharedMaterial = new Material(shader)
						{
							color = val3
						};
						socketGizmo.Axes.Add(val4);
					}
					_gizmos.Add(socketGizmo);
				}
			}
		}

		internal void SetVisible(bool visible)
		{
			((Behaviour)this).enabled = visible;
			foreach (SocketGizmo gizmo in _gizmos)
			{
				foreach (LineRenderer axis in gizmo.Axes)
				{
					if ((Object)(object)axis != (Object)null)
					{
						((Renderer)axis).enabled = visible;
					}
				}
			}
		}

		private void LateUpdate()
		{
			UpdateAxes();
		}

		private void UpdateAxes()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: 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)
			foreach (SocketGizmo gizmo in _gizmos)
			{
				if ((Object)(object)gizmo.Bone == (Object)null)
				{
					continue;
				}
				for (int i = 0; i < gizmo.Axes.Count; i++)
				{
					LineRenderer val = gizmo.Axes[i];
					if (!((Object)(object)val == (Object)null))
					{
						Vector3 val2 = (Vector3)(i switch
						{
							1 => gizmo.Bone.up, 
							0 => gizmo.Bone.right, 
							_ => gizmo.Bone.forward, 
						});
						val.SetPosition(0, Vector3.zero);
						val.SetPosition(1, gizmo.Bone.InverseTransformVector(val2 * 0.12f));
					}
				}
			}
		}

		private void OnGUI()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_0050: Expected O, but got Unknown
			//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_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_00d2: 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_00f5: 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_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: 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)
			Camera main = Camera.main;
			if ((Object)(object)main == (Object)null || (int)Event.current.type != 7)
			{
				return;
			}
			if (_labelStyle == null)
			{
				_labelStyle = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)7,
					fontSize = 14,
					fontStyle = (FontStyle)1
				};
			}
			Rect val2 = default(Rect);
			foreach (SocketGizmo gizmo in _gizmos)
			{
				if (!((Object)(object)gizmo.Bone == (Object)null) && ((Component)gizmo.Bone).gameObject.activeInHierarchy)
				{
					Vector3 val = main.WorldToScreenPoint(gizmo.Bone.position);
					if (!(val.z <= 0f) && !(val.x < 0f) && !(val.x > (float)Screen.width) && !(val.y < 0f) && !(val.y > (float)Screen.height))
					{
						((Rect)(ref val2))..ctor(val.x - 160f, (float)Screen.height - val.y - 32f, 320f, 24f);
						_labelStyle.normal.textColor = Color.black;
						GUI.Label(new Rect(((Rect)(ref val2)).x + 1f, ((Rect)(ref val2)).y + 1f, ((Rect)(ref val2)).width, ((Rect)(ref val2)).height), gizmo.Label, _labelStyle);
						_labelStyle.normal.textColor = Color.white;
						GUI.Label(val2, gizmo.Label, _labelStyle);
					}
				}
			}
		}

		private void ClearGizmos()
		{
			foreach (SocketGizmo gizmo in _gizmos)
			{
				foreach (LineRenderer axis in gizmo.Axes)
				{
					if (!((Object)(object)axis == (Object)null))
					{
						Object.Destroy((Object)(object)((Renderer)axis).sharedMaterial);
						Object.Destroy((Object)(object)((Component)axis).gameObject);
					}
				}
			}
			_gizmos.Clear();
		}

		private void OnDestroy()
		{
			ClearGizmos();
		}
	}
	[DisallowMultipleComponent]
	public sealed class AttachmentReference : MonoBehaviour
	{
		private bool _captured;

		private float3 _offsetInSocketAxes;

		private Vector3 _worldScale;

		public void Capture()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0068: Unknown result type (might be due to invalid IL or missing references)
			if (!_captured && !((Object)(object)((Component)this).transform.parent == (Object)null))
			{
				_offsetInSocketAxes = AttachmentMath.ToSocketOffset(AttachmentTransforms.Vector(((Component)this).transform.parent.position), AttachmentTransforms.Vector(((Component)this).transform.position), AttachmentTransforms.Rotation(((Component)this).transform.rotation));
				_worldScale = ((Component)this).transform.lossyScale;
				_captured = true;
			}
		}

		public bool Reparent(Transform parent, Quaternion rotation, float ratio, Vector3? scaleOverride)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_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_0032: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			Capture();
			if (!_captured || (Object)(object)parent == (Object)null)
			{
				return false;
			}
			float4x4 parentToWorld = AttachmentTransforms.Matrix(parent.localToWorldMatrix);
			if (!AttachmentMath.TryMapSocket(parentToWorld, AttachmentTransforms.Rotation(parent.rotation), AttachmentTransforms.Rotation(rotation), _offsetInSocketAxes, ratio, out var localPosition))
			{
				return false;
			}
			if (!AttachmentMath.TryLocalScale(parentToWorld, AttachmentTransforms.Rotation(rotation), AttachmentTransforms.Vector(_worldScale), out var localScale))
			{
				return false;
			}
			((Component)this).transform.SetParent(parent, false);
			((Component)this).transform.SetLocalPositionAndRotation(AttachmentTransforms.Vector(localPosition), rotation);
			((Component)this).transform.localScale = (Vector3)(((??)scaleOverride) ?? AttachmentTransforms.Vector(localScale));
			return true;
		}
	}
	internal static class AttachmentTransforms
	{
		public static float3 Vector(Vector3 value)
		{
			//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_000c: 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)
			return new float3(value.x, value.y, value.z);
		}

		public static Vector3 Vector(float3 value)
		{
			//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_000c: 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)
			return new Vector3(value.x, value.y, value.z);
		}

		public static quaternion Rotation(Quaternion value)
		{
			//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_000c: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			return new quaternion(value.x, value.y, value.z, value.w);
		}

		public static float4x4 Matrix(Matrix4x4 value)
		{
			//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_000c: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			return new float4x4(new float4(value.m00, value.m10, value.m20, value.m30), new float4(value.m01, value.m11, value.m21, value.m31), new float4(value.m02, value.m12, value.m22, value.m32), new float4(value.m03, value.m13, value.m23, value.m33));
		}
	}
	[DisallowMultipleComponent]
	public sealed class EquipmentTransformReference : MonoBehaviour
	{
		private bool _captured;

		private Vector3 _worldScale;

		private Quaternion _localRotation;

		private Vector3 _baseOffsetInMeters;

		public static EquipmentTransformReference Get(Transform item)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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_004c: 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)
			EquipmentTransformReference equipmentTransformReference = ((Component)item).GetComponent<EquipmentTransformReference>();
			if ((Object)(object)equipmentTransformReference == (Object)null)
			{
				equipmentTransformReference = ((Component)item).gameObject.AddComponent<EquipmentTransformReference>();
			}
			if (!equipmentTransformReference._captured)
			{
				equipmentTransformReference._worldScale = item.lossyScale;
				equipmentTransformReference._localRotation = item.localRotation;
				equipmentTransformReference._baseOffsetInMeters = (((Object)(object)item.parent != (Object)null) ? (Quaternion.Inverse(item.parent.rotation) * (item.position - item.parent.position)) : item.position);
				equipmentTransformReference._captured = true;
			}
			return equipmentTransformReference;
		}

		public void SetScale(float ratio)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			SetScale(ratio, Vector3.one);
		}

		public void SetScale(float ratio, Vector3 multiplier)
		{
			//IL_003e: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0064: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			if (!(ratio <= 0f) && !float.IsNaN(ratio) && !float.IsInfinity(ratio) && AttachmentMath.TryLocalScale(AttachmentTransforms.Matrix(((Object)(object)((Component)this).transform.parent != (Object)null) ? ((Component)this).transform.parent.localToWorldMatrix : Matrix4x4.identity), AttachmentTransforms.Rotation(((Component)this).transform.localRotation), AttachmentTransforms.Vector(Vector3.Scale(_worldScale * ratio, multiplier)), out var localScale))
			{
				((Component)this).transform.localScale = AttachmentTransforms.Vector(localScale);
			}
		}

		public void SetRotationOffset(Vector3 offset)
		{
			//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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.localRotation = _localRotation * Quaternion.Euler(offset);
		}

		public void SetPositionOffset(Vector3 offsetInMeters, float ratio)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			Transform parent = ((Component)this).transform.parent;
			Matrix4x4 value = (((Object)(object)parent != (Object)null) ? parent.localToWorldMatrix : Matrix4x4.identity);
			if (AttachmentMath.TryMapItemOffset(socketRotation: AttachmentTransforms.Rotation(((Object)(object)parent != (Object)null) ? parent.rotation : Quaternion.identity), socketToWorld: AttachmentTransforms.Matrix(value), offsetInMeters: AttachmentTransforms.Vector(_baseOffsetInMeters + offsetInMeters), ratio: ratio, localPosition: out var localPosition))
			{
				((Component)this).transform.localPosition = AttachmentTransforms.Vector(localPosition);
			}
		}
	}
	public sealed class BindPoseSpace : MonoBehaviour
	{
		public bool UseRoot;

		public static void Detect(GameObject root)
		{
			//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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			SkinnedMeshRenderer[] componentsInChildren = root.GetComponentsInChildren<SkinnedMeshRenderer>(true);
			foreach (SkinnedMeshRenderer val in componentsInChildren)
			{
				Mesh sharedMesh = val.sharedMesh;
				if ((Object)(object)sharedMesh == (Object)null || !sharedMesh.isReadable || (Object)(object)((Component)val).GetComponent<BindPoseSpace>() != (Object)null)
				{
					continue;
				}
				Transform[] bones = val.bones;
				Matrix4x4[] bindposes = sharedMesh.bindposes;
				int num = 0;
				int num2 = 0;
				for (int j = 0; j < bones.Length && j < bindposes.Length; j++)
				{
					if (!((Object)(object)bones[j] == (Object)null))
					{
						Matrix4x4 inverse = ((Matrix4x4)(ref bindposes[j])).inverse;
						Vector3 val2 = ((Matrix4x4)(ref inverse)).MultiplyPoint3x4(Vector3.zero);
						Vector3 position = bones[j].position;
						Vector3 val3 = root.transform.TransformPoint(val2) - position;
						float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
						val3 = ((Component)val).transform.TransformPoint(val2) - position;
						float sqrMagnitude2 = ((Vector3)(ref val3)).sqrMagnitude;
						if (sqrMagnitude < sqrMagnitude2)
						{
							num++;
						}
						else
						{
							num2++;
						}
					}
				}
				((Component)val).gameObject.AddComponent<BindPoseSpace>().UseRoot = num > num2;
			}
		}
	}
	public sealed class WallSensor : MonoBehaviour
	{
		private const float Radius = 0.49f;

		private const float Thickness = 0.04f;

		private const int Sides = 24;

		private static Mesh _mesh;

		private static readonly Dictionary<Player, WallSensor> Sensors = new Dictionary<Player, WallSensor>();

		private readonly HashSet<Collider> _touching = new HashSet<Collider>();

		internal static void Attach(Player player)
		{
			//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_0033: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)player == (Object)null) && !Sensors.ContainsKey(player))
			{
				GameObject val = new GameObject("wall sensor")
				{
					layer = ((Component)player).gameObject.layer
				};
				val.transform.SetParent(((Component)player).transform, false);
				val.transform.localPosition = new Vector3(0f, 0.49f, 0f);
				MeshCollider obj = val.AddComponent<MeshCollider>();
				obj.sharedMesh = _mesh ?? (_mesh = BuildDisk());
				obj.convex = true;
				((Collider)obj).isTrigger = true;
				Sensors[player] = val.AddComponent<WallSensor>();
			}
		}

		internal static void Detach(Player player)
		{
			if (!((Object)(object)player == (Object)null) && Sensors.TryGetValue(player, out var value))
			{
				Sensors.Remove(player);
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
			}
		}

		internal static bool Touching(Player player, Collider collider)
		{
			if (Sensors.TryGetValue(player, out var value) && (Object)(object)value != (Object)null)
			{
				return value._touching.Contains(collider);
			}
			return false;
		}

		private void OnTriggerEnter(Collider other)
		{
			_touching.Add(other);
		}

		private void OnTriggerExit(Collider other)
		{
			_touching.Remove(other);
		}

		private static Mesh BuildDisk()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: 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_013c: Expected O, but got Unknown
			Vector3[] array = (Vector3[])(object)new Vector3[48];
			for (int i = 0; i < 24; i++)
			{
				float num = (float)i * (float)Math.PI * 2f / 24f;
				float num2 = Mathf.Cos(num) * 0.49f;
				float num3 = Mathf.Sin(num) * 0.49f;
				array[i] = new Vector3(num2, -0.02f, num3);
				array[i + 24] = new Vector3(num2, 0.02f, num3);
			}
			List<int> list = new List<int>();
			for (int j = 0; j < 24; j++)
			{
				int num4 = (j + 1) % 24;
				list.AddRange(new int[6]
				{
					j,
					num4,
					j + 24,
					num4,
					num4 + 24,
					j + 24
				});
				if (j < 22)
				{
					list.AddRange(new int[3]
					{
						0,
						j + 2,
						j + 1
					});
					list.AddRange(new int[3]
					{
						24,
						24 + j + 1,
						24 + j + 2
					});
				}
			}
			Mesh val = new Mesh
			{
				name = "wall sensor",
				vertices = array,
				triangles = list.ToArray()
			};
			val.RecalculateNormals();
			val.RecalculateBounds();
			return val;
		}
	}
	public sealed class RiggedItemPieces : MonoBehaviour
	{
		internal Animator Avatar;

		internal readonly List<Transform> Moved = new List<Transform>();

		private void OnDestroy()
		{
			foreach (Transform item in Moved)
			{
				if ((Object)(object)item != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)item).gameObject);
				}
			}
		}
	}
	public sealed class CapsuleGizmo : MonoBehaviour
	{
		private sealed class Shape
		{
			internal GameObject Middle;

			internal GameObject Top;

			internal GameObject Bottom;

			internal void Fit(Vector3 center, float radius, float height)
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_00a1: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				float num = Mathf.Max(0f, height / 2f - radius);
				Middle.transform.position = center;
				Middle.transform.localScale = new Vector3(radius * 2f, num, radius * 2f);
				Top.transform.position = center + Vector3.up * num;
				Bottom.transform.position = center - Vector3.up * num;
				Transform transform = Top.transform;
				Vector3 localScale = (Bottom.transform.localScale = Vector3.one * (radius * 2f));
				transform.localScale = localScale;
			}

			internal void Destroy()
			{
				Object.Destroy((Object)(object)Middle);
				Object.Destroy((Object)(object)Top);
				Object.Destroy((Object)(object)Bottom);
			}
		}

		private static Material _red;

		private static Material _blue;

		private static Material _green;

		private Shape _live;

		private Shape _vanilla;

		private GameObject _sensor;

		private CapsuleCollider _capsule;

		internal static string Set(Player player, bool show)
		{
			if ((Object)(object)player == (Object)null)
			{
				return "Enter a world first.";
			}
			CapsuleGizmo component = ((Component)player).GetComponent<CapsuleGizmo>();
			if (!show)
			{
				if ((Object)(object)component != (Object)null)
				{
					Object.Destroy((Object)(object)component);
				}
				return "Capsules hidden.";
			}
			if ((Object)(object)component == (Object)null)
			{
				((Component)player).gameObject.AddComponent<CapsuleGizmo>();
			}
			return "Capsules shown: red is the live one, blue the vanilla one, green the wall sensor.";
		}

		private void Awake()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			_capsule = ((Component)this).GetComponent<CapsuleCollider>();
			_live = Capsule(_red ?? (_red = Translucent(new Color(1f, 0f, 0f, 0.3f))));
			_vanilla = Capsule(_blue ?? (_blue = Translucent(new Color(0f, 0.4f, 1f, 0.2f))));
			_sensor = Primitive((PrimitiveType)2, _green ?? (_green = Translucent(new Color(0f, 1f, 0f, 0.35f))));
		}

		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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)this).transform.position;
			if ((Object)(object)_capsule != (Object)null)
			{
				Shape live = _live;
				Bounds bounds = ((Collider)_capsule).bounds;
				live.Fit(((Bounds)(ref bounds)).center, _capsule.radius, _capsule.height);
			}
			_vanilla.Fit(position + Vector3.up * 0.925f, 0.49f, 1.85f);
			_sensor.transform.position = position + Vector3.up * 0.49f;
			_sensor.transform.localScale = new Vector3(0.98f, 0.02f, 0.98f);
		}

		private static Shape Capsule(Material material)
		{
			return new Shape
			{
				Middle = Primitive((PrimitiveType)2, material),
				Top = Primitive((PrimitiveType)0, material),
				Bottom = Primitive((PrimitiveType)0, material)
			};
		}

		private static GameObject Primitive(PrimitiveType type, Material material)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GameObject.CreatePrimitive(type);
			((Object)obj).name = "CapsuleGizmo";
			((Renderer)obj.GetComponent<MeshRenderer>()).sharedMaterial = material;
			Object.Destroy((Object)(object)obj.GetComponent<Collider>());
			return obj;
		}

		private static Material Translucent(Color color)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			Material val = new Material(Shader.Find("Standard"));
			val.SetFloat("_Mode", 2f);
			val.SetInt("_SrcBlend", 5);
			val.SetInt("_DstBlend", 10);
			val.SetInt("_ZWrite", 0);
			val.DisableKeyword("_ALPHATEST_ON");
			val.EnableKeyword("_ALPHABLEND_ON");
			val.DisableKeyword("_ALPHAPREMULTIPLY_ON");
			val.SetFloat("_GlossMapScale", 0f);
			val.renderQueue = 3000;
			val.color = color;
			return val;
		}

		private void OnDestroy()
		{
			_live?.Destroy();
			_vanilla?.Destroy();
			Object.Destroy((Object)(object)_sensor);
		}
	}
	public static class AttachmentMath
	{
		public static float3 ToSocketOffset(float3 parentPosition, float3 socketPosition, quaternion socketRotation)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			return math.rotate(math.inverse(socketRotation), socketPosition - parentPosition);
		}

		public static bool TryMapSocket(float4x4 parentToWorld, quaternion parentRotation, quaternion socketLocalRotation, float3 originalOffset, float ratio, out float3 localPosition)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: 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_0046: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			localPosition = float3.zero;
			if (!math.isfinite(ratio) || ratio <= 0f || !Finite(parentToWorld))
			{
				return false;
			}
			float num = math.determinant(parentToWorld);
			if (!math.isfinite(num) || math.abs(num) < 1E-12f)
			{
				return false;
			}
			float3 val = math.rotate(math.mul(parentRotation, socketLocalRotation), originalOffset * ratio);
			float4 val2 = math.mul(math.inverse(parentToWorld), new float4(val, 0f));
			localPosition = ((float4)(ref val2)).xyz;
			return math.all(math.isfinite(localPosition));
		}

		public static bool TryLocalScale(float4x4 parentToWorld, quaternion localRotation, float3 worldScale, out float3 localScale)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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_004d: 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_005d: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: 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_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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			localScale = new float3(1);
			if (!Finite(parentToWorld) || !math.all(math.isfinite(worldScale)))
			{
				return false;
			}
			float3x3 val = math.mul(new float3x3(parentToWorld), new float3x3(localRotation));
			float3 val2 = default(float3);
			((float3)(ref val2))..ctor(math.length(val.c0), math.length(val.c1), math.length(val.c2));
			if (!math.all(math.isfinite(val2)) || math.any(val2 < 1E-06f))
			{
				return false;
			}
			localScale = worldScale / val2;
			return math.all(math.isfinite(localScale));
		}

		public static bool TryMapItemOffset(float4x4 socketToWorld, quaternion socketRotation, float3 offsetInMeters, float ratio, out float3 localPosition)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return TryMapSocket(socketToWorld, socketRotation, quaternion.identity, offsetInMeters, ratio, out localPosition);
		}

		public static float3 ToBoneOffset(quaternion boneRotation, float3 worldOffset, float3 adjustment)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: 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)
			return math.rotate(math.inverse(boneRotation), worldOffset) + adjustment;
		}

		public static float3 PlaceBone(float3 handPosition, quaternion boneRotation, float3 offset)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return handPosition + math.rotate(boneRotation, offset);
		}

		public static float3 SeatedHipCorrection(float3 vanillaHips, float3 avatarHips, quaternion seatRotation)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			float3 val = math.rotate(math.inverse(seatRotation), vanillaHips - avatarHips);
			val.x = 0f;
			return math.rotate(seatRotation, val);
		}

		public static float3 GetSeatProportions(float3 vanilla, float3 avatar)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_001a: 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_002c: 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_0049: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			if (!math.all(math.isfinite(vanilla)) || !math.all(math.isfinite(avatar)) || math.any(vanilla <= 0f) || math.any(avatar <= 0f))
			{
				return float3.zero;
			}
			return new float3(1f, avatar.y - vanilla.y, avatar.z - vanilla.z);
		}

		public static float3 SeatedProportionCorrection(float3 vanillaHips, float3 avatarHips, float3 vanillaKnees, float3 avatarKnees, float3 seatOrigin, quaternion seatRotation, float3 proportions, bool forwardOnly)
		{
			//IL_0000: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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_004d: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_00bb: 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_009c: Unknown result type (might be due to invalid IL or missing references)
			if (proportions.x <= 0f)
			{
				return SeatedHipCorrection(vanillaHips, avatarHips, seatRotation);
			}
			quaternion val = math.inverse(seatRotation);
			float3 val2 = math.rotate(val, vanillaHips - seatOrigin);
			float3 val3 = math.rotate(val, avatarHips - seatOrigin);
			float3 val4 = math.rotate(val, vanillaKnees - seatOrigin);
			float3 val5 = math.rotate(val, avatarKnees - seatOrigin);
			float3 val6 = val2 - val3;
			val6.y += proportions.y;
			val6.z = val4.z - val5.z + proportions.z;
			if (forwardOnly)
			{
				val6.z = math.max(0f, val6.z);
			}
			val6.x = 0f;
			return math.rotate(seatRotation, val6);
		}

		private static bool Finite(float4x4 matrix)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (math.all(math.isfinite(matrix.c0)) && math.all(math.isfinite(matrix.c1)) && math.all(math.isfinite(matrix.c2)))
			{
				return math.all(math.isfinite(matrix.c3));
			}
			return false;
		}
	}
	internal sealed class SeatSupportMeasurement
	{
		internal const int Hips = 1;

		internal const int LeftThigh = 2;

		internal const int RightThigh = 3;

		internal const int Foot = 4;

		internal const int LeftShin = 5;

		internal const int RightShin = 6;

		private readonly float3 _hips;

		private readonly float3 _leftThigh;

		private readonly float3 _rightThigh;

		private readonly float3 _leftKnee;

		private readonly float3 _rightKnee;

		private readonly quaternion _leftBend;

		private readonly quaternion _rightBend;

		private readonly quaternion _leftShinBend;

		private readonly quaternion _rightShinBend;

		private readonly float _leftShinLength;

		private readonly float _rightShinLength;

		private readonly List<float> _leftThickness = new List<float>();

		private readonly List<float> _rightThickness = new List<float>();

		private readonly List<float> _leftCalf = new List<float>();

		private readonly List<float> _rightCalf = new List<float>();

		private readonly List<float> _ground = new List<float>();

		internal SeatSupportMeasurement(float3 hips, float3 leftThigh, float3 rightThigh, quaternion leftBend, quaternion rightBend, float3 leftKnee, float3 rightKnee, quaternion leftShinBend, quaternion rightShinBend, float leftShinLength, float rightShinLength)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			_hips = hips;
			_leftThigh = leftThigh;
			_rightThigh = rightThigh;
			_leftBend = leftBend;
			_rightBend = rightBend;
			_leftKnee = leftKnee;
			_rightKnee = rightKnee;
			_leftShinBend = leftShinBend;
			_rightShinBend = rightShinBend;
			_leftShinLength = leftShinLength;
			_rightShinLength = rightShinLength;
		}

		internal void Add(float3 vertex, int4 groups, float4 weights)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_006a: 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_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_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: 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_0108: 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_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			if (!math.all(math.isfinite(vertex)) || !math.all(math.isfinite(weights)))
			{
				return;
			}
			int num = 0;
			for (int i = 1; i < 4; i++)
			{
				if (((float4)(ref weights))[i] > ((float4)(ref weights))[num])
				{
					num = i;
				}
			}
			if (!(((float4)(ref weights))[num] < 0.5f) && ((int4)(ref groups))[num] != 0)
			{
				switch (((int4)(ref groups))[num])
				{
				case 4:
					_ground.Add(vertex.y);
					break;
				case 2:
					_leftThickness.Add(0f - math.rotate(_leftBend, vertex - _leftThigh).y);
					break;
				case 3:
					_rightThickness.Add(0f - math.rotate(_rightBend, vertex - _rightThigh).y);
					break;
				case 5:
					AddCalf(_leftCalf, math.rotate(_leftShinBend, vertex - _leftKnee), _leftShinLength);
					break;
				case 6:
					AddCalf(_rightCalf, math.rotate(_rightShinBend, vertex - _rightKnee), _rightShinLength);
					break;
				}
			}
		}

		private static void AddCalf(List<float> calf, float3 bent, float length)
		{
			//IL_0000: 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_001d: Unknown result type (might be due to invalid IL or missing references)
			if (bent.z >= 0f && bent.z <= length * 0.5f)
			{
				calf.Add(0f - bent.y);
			}
		}

		internal bool TryMeasure(out float3 support)
		{
			//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_019d: 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_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			support = float3.zero;
			if (_leftThickness.Count < 8 || _rightThickness.Count < 8 || _ground.Count < 8 || _leftCalf.Count < 8 || _rightCalf.Count < 8)
			{
				return false;
			}
			_leftThickness.Sort();
			_rightThickness.Sort();
			_leftCalf.Sort();
			_rightCalf.Sort();
			_ground.Sort();
			float num = math.max(0f, _leftThickness[(int)((float)_leftThickness.Count * 0.98f)]);
			float num2 = math.max(0f, _rightThickness[(int)((float)_rightThickness.Count * 0.98f)]);
			float num3 = math.max(0f, _leftCalf[(int)((float)_leftCalf.Count * 0.98f)]);
			float num4 = math.max(0f, _rightCalf[(int)((float)_rightCalf.Count * 0.98f)]);
			float num5 = _hips.y - _ground[(int)((float)_ground.Count * 0.02f)];
			float num6 = _hips.y - (_leftThigh.y + _rightThigh.y) * 0.5f;
			support = new float3(num5, num6 + (num + num2) * 0.5f, (num3 + num4) * 0.5f);
			if (math.all(math.isfinite(support)) && num5 > 0f && support.y > 0f)
			{
				return support.z > 0f;
			}
			return false;
		}
	}
	public sealed class FixedRotationSmoother
	{
		private bool _ready;

		private float _sampleTime;

		private float3 _samplePosition;

		private quaternion _previous;

		private quaternion _current;

		public void Reset()
		{
			_ready = false;
		}

		public quaternion Sample(quaternion rotation, float3 position, float fixedTime, float renderTime, float fixedDelta)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_005c: Unknown result type (might be due to invalid IL or missing references)
			if (!_ready || fixedDelta <= 0f || !math.isfinite(fixedDelta) || fixedTime < _sampleTime || fixedTime - _sampleTime > fixedDelta * 2.5f || math.distancesq(position, _samplePosition) > 25f || (_ready && math.abs(math.dot(rotation.value, _current.value)) < 0.7071067f))
			{
				_previous = (_current = rotation);
				_sampleTime = fixedTime;
				_samplePosition = position;
				_ready = true;
				return rotation;
			}
			if (fixedTime > _sampleTime)
			{
				_previous = _current;
				_current = rotation;
				_sampleTime = fixedTime;
				_samplePosition = position;
			}
			float num = math.saturate((renderTime - fixedTime) / fixedDelta);
			return math.slerp(_previous, _current, num);
		}
	}
	internal static class FrameClock
	{
		private static bool _installed;

		private static int _startFrame = -1;

		private static double _start;

		private static double _updateEnd;

		private static double _tailMs;

		private static double _deadlineMs;

		private static double _overshootMs;

		private static readonly List<string> _notes = new List<string>();

		private static double _importMs;

		internal static double ReportAboveMs;

		internal static bool Installed => _installed;

		internal static double WorstFrameMs { get; private set; }

		internal static string Label
		{
			set
			{
				if (_notes.Count == 6)
				{
					_notes.RemoveAt(0);
				}
				_notes.Add("+" + ((Time.realtimeSinceStartupAsDouble - _start) * 1000.0).ToString("F0") + "ms " + value);
			}
		}

		internal static bool Reporting => ReportAboveMs > 0.0;

		internal static void Charge(double ms)
		{
			_importMs += ms;
		}

		internal static void ResetWorst()
		{
			WorstFrameMs = 0.0;
		}

		internal static void Install()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			if (_installed)
			{
				return;
			}
			try
			{
				PlayerLoopSystem loop = PlayerLoop.GetCurrentPlayerLoop();
				if (!AddFirst(ref loop, typeof(EarlyUpdate), new UpdateFunction(MarkStart)) || !AddFirst(ref loop, typeof(PreLateUpdate), new UpdateFunction(MarkUpdateEnd)) || !AddBefore(ref loop, typeof(PostLateUpdate), typeof(PresentAfterDraw), new UpdateFunction(MarkEnd)))
				{
					Logger.LogWarning("Could not hook the player loop, avatar loads use the fixed slice.");
					return;
				}
				PlayerLoop.SetPlayerLoop(loop);
				_installed = true;
				if (Settings.LogLoadTiming)
				{
					Logger.Log("Frame clock hooked into the player loop.");
				}
			}
			catch (Exception ex)
			{
				Logger.LogWarning("Could not hook the player loop, avatar loads use the fixed slice: " + ex.Message);
			}
		}

		internal static float SpareMs(double frameMs)
		{
			if (!_installed || _startFrame != Time.frameCount)
			{
				return -1f;
			}
			_deadlineMs = frameMs;
			double num = (Time.realtimeSinceStartupAsDouble - _start) * 1000.0;
			return Mathf.Max(2f, (float)(frameMs - num - _tailMs - _overshootMs - 1.0));
		}

		private static void MarkStart()
		{
			double realtimeSinceStartupAsDouble = Time.realtimeSinceStartupAsDouble;
			if (_startFrame == Time.frameCount - 1)
			{
				double num = (realtimeSinceStartupAsDouble - _start) * 1000.0;
				WorstFrameMs = Math.Max(WorstFrameMs, num);
				if (ReportAboveMs > 0.0 && num > ReportAboveMs)
				{
					Logger.Log("Long frame " + num.ToString("F0") + "ms: update part " + ((_updateEnd - _start) * 1000.0).ToString("F0") + "ms, render part " + ((realtimeSinceStartupAsDouble - _updateEnd) * 1000.0).ToString("F0") + "ms, import used " + _importMs.ToString("F1") + "ms; " + string.Join(", ", _notes));
				}
			}
			_notes.Clear();
			_importMs = 0.0;
			if (_startFrame == Time.frameCount - 1 && _deadlineMs > 0.0)
			{
				double num2 = (realtimeSinceStartupAsDouble - _start) * 1000.0 - _deadlineMs;
				_overshootMs = ((num2 > 0.0) ? Math.Max(num2, _overshootMs) : (_overshootMs * 0.5));
			}
			_startFrame = Time.frameCount;
			_start = realtimeSinceStartupAsDouble;
		}

		private static void MarkUpdateEnd()
		{
			_updateEnd = Time.realtimeSinceStartupAsDouble;
		}

		private static void MarkEnd()
		{
			_tailMs = Math.Max((Time.realtimeSinceStartupAsDouble - _updateEnd) * 1000.0, _tailMs * 0.9);
		}

		private static bool AddFirst(ref PlayerLoopSystem loop, Type phase, UpdateFunction fn)
		{
			return Edit(ref loop, phase, delegate(List<PlayerLoopSystem> list)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				list.Insert(0, Stamp(fn));
			});
		}

		internal static bool AddBefore(ref PlayerLoopSystem loop, Type phase, Type before, UpdateFunction fn, Type owner = null)
		{
			return Edit(ref loop, phase, delegate(List<PlayerLoopSystem> list)
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				int num = list.FindIndex((PlayerLoopSystem s) => s.type == before);
				list.Insert((num < 0) ? list.Count : num, Stamp(fn, owner));
			});
		}

		private static PlayerLoopSystem Stamp(UpdateFunction fn, Type owner = null)
		{
			//IL_0002: 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)
			return new PlayerLoopSystem
			{
				type = (owner ?? typeof(FrameClock)),
				updateDelegate = fn
			};
		}

		private static bool Edit(ref PlayerLoopSystem loop, Type phase, Action<List<PlayerLoopSystem>> edit)
		{
			if (loop.subSystemList == null)
			{
				return false;
			}
			for (int i = 0; i < loop.subSystemList.Length; i++)
			{
				if (!(loop.subSystemList[i].type != phase))
				{
					List<PlayerLoopSystem> list = new List<PlayerLoopSystem>(loop.subSystemList[i].subSystemList ?? Array.Empty<PlayerLoopSystem>());
					edit(list);
					loop.subSystemList[i].subSystemList = list.ToArray();
					return true;
				}
			}
			return false;
		}
	}
	internal static class VisEquipmentExtensions
	{
		private static readonly Dictionary<string, FieldInfo> Fields = new Dictionary<string, FieldInfo>();

		private static object ReadField(VisEquipment equipment, string name)
		{
			if (!Fields.TryGetValue(name, out var value))
			{
				value = AccessTools.Field(typeof(VisEquipment), name);
				Fields[name] = value;
			}
			return value?.GetValue(equipment);
		}

		public static string GetEquippedItemName(this VisEquipment equipment, string fieldName)
		{
			if ((Object)(object)equipment == (Object)null || string.IsNullOrEmpty(fieldName) || !fieldName.StartsWith("m_", StringComparison.Ordinal) || fieldName.Length < 3)
			{
				return null;
			}
			string name = "m_current" + char.ToUpperInvariant(fieldName[2]) + fieldName.Substring(3) + "Hash";
			if (!(ReadField(equipment, name) is int num) || num == 0)
			{
				return null;
			}
			if (!((Object)(object)ObjectDB.instance != (Object)null))
			{
				return null;
			}
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(num);
			if (itemPrefab == null)
			{
				return null;
			}
			return ((Object)itemPrefab).name;
		}
	}
	public static class Constants
	{
		public static class Vrm
		{
			public static readonly string GoName = "evv__vrm";

			public static readonly string DefaultName = "___Default.vrm";

			public static readonly string Dir = PluginDir;

			public static readonly string[] ReadDirs = new string[2]
			{
				Path.Combine(PluginDir, "test"),
				PluginDir
			};

			public static string DefaultPath => Find(DefaultName);

			public static string Find(string fileName)
			{
				string text = Path.Combine(Dir, fileName);
				if (File.Exists(text))
				{
					return text;
				}
				Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
				string[] readDirs = ReadDirs;
				foreach (string path in readDirs)
				{
					if (!Directory.Exists(path))
					{
						continue;
					}
					foreach (string item in Directory.EnumerateFiles(path))
					{
						dictionary[Path.GetFileName(item)] = item;
					}
				}
				if (!dictionary.TryGetValue(fileName, out var value))
				{
					return text;
				}
				return value;
			}
		}

		public static class Shaders
		{
			public static readonly string Dir = Resolve();

			private static string Resolve()
			{
				string directoryName = Path.GetDirectoryName(typeof(Constants).Assembly.Location);
				if (directoryName != null)
				{
					if (File.Exists(Path.Combine(directoryName, "UniVrm.shaders")))
					{
						return directoryName;
					}
					string text = Path.Combine(directoryName, "shaders");
					if (File.Exists(Path.Combine(text, "UniVrm.shaders")))
					{
						return text;
					}
				}
				return Path.Combine(PluginDir, "shaders");
			}
		}

		public static class Keys
		{
			public static readonly string PlayerName = "evv_PlayerName";
		}

		public static class VanillaCapsule
		{
			public const float Radius = 0.49f;

			public const float Height = 1.85f;

			public const float Center = 0.925f;
		}

		public const string PluginName = "EnhancedValheimVRM";

		private static readonly string PluginDir = Path.Combine(Environment.CurrentDirectory, "EnhancedValheimVRM");

		private const string Prefix = "evv_";
	}
	public sealed class SharedVrmLifetime : MonoBehaviour
	{
		public readonly List<Object> ExtraResources = new List<Object>();

		internal readonly HashSet<Material> ConvertedMaterials = new HashSet<Material>();

		internal Action CacheReleased;

		internal event Action<Material> MaterialReady;

		internal void NotifyMaterial(Material material)
		{
			if ((Object)(object)material != (Object)null)
			{
				ConvertedMaterials.Add(material);
			}
			this.MaterialReady?.Invoke(material);
		}

		public void Release()
		{
			foreach (Object extraResource in ExtraResources)
			{
				if (extraResource != (Object)null)
				{
					Object.Destroy(extraResource);
				}
			}
			ExtraResources.Clear();
			ConvertedMaterials.Clear();
			this.MaterialReady = null;
			Action cacheReleased = CacheReleased;
			CacheReleased = null;
			cacheReleased?.Invoke();
		}

		private void OnDestroy()
		{
			Release();
		}
	}
	public sealed class EmbeddedSharingHost : MonoBehaviour
	{
		private ZNet _network;

		private CancellationTokenSource _stop;

		private Task _serving;

		private Task<int> _listening;

		private volatile AvatarTcpServer _storage;

		private Task _stopping = Task.CompletedTask;

		private Task _addressCheck;

		private float _nextCheck;

		private float _nextAddressCheck = 3600f;

		private int _port;

		private int _facePort;

		private int _bytesPerSecond;

		private int _slots;

		private int _bundleLimit;

		private int _uploadMbps;

		private string _bindAddress;

		private bool _dedicated;

		private static readonly string[] PublicAddressServices = new string[5] { "https://ipv4.icanhazip.com/", "https://api.ipify.org", "https://ipv4.myip.wtf/text", "https://checkip.amazonaws.com/", "https://ipinfo.io/ip/" };

		internal AvatarTcpServer Storage
		{
			get
			{
				if (ListeningPort == 0)
				{
					return null;
				}
				return _storage;
			}
		}

		internal int ListeningPort
		{
			get
			{
				if ((Object)(object)_network != (Object)null && (Object)(object)_network == (Object)(object)ZNet.instance && _network.IsServer() && _network.IsDedicated() && Settings.EnableSharingServer && _serving != null && !_serving.IsCompleted)
				{
					Task<int> listening = _listening;
					if (listening != null && listening.Status == TaskStatus.RanToCompletion)
					{
						return _listening.Result;
					}
				}
				return 0;
			}
		}

		private void Update()
		{
			if (Time.realtimeSinceStartup < _nextCheck)
			{
				return;
			}
			_nextCheck = Time.realtimeSinceStartup + 1f;
			ZNet instance = ZNet.instance;
			if ((Object)(object)instance != (Object)null && instance.IsServer() && !instance.IsDedicated() && ZNet.IsOpenServer() && Settings.EnableSharingServer)
			{
				Logger.LogOnce("sharing-player-host", "Player-hosted VRM sharing is disabled: no verified TCP hole-punch path is implemented. Dedicated-server sharing remains available.");
			}
			if ((Object)(object)instance == (Object)null || !SharingEndpoint.ShouldHost(instance.IsServer(), instance.IsDedicated(), Settings.EnableSharingServer))
			{
				StopHost();
				return;
			}
			if (Time.realtimeSinceStartup >= _nextAddressCheck && (_addressCheck == null || _addressCheck.IsCompleted))
			{
				_nextAddressCheck = Time.realtimeSinceStartup + 3600f;
				_addressCheck = Task.Run(delegate
				{
					SharingRpc.SetPublicAddress(LookUpPublicAddress());
				});
			}
			SharingDownloadPolicy policy = Settings.GetDownloadPolicy();
			if (_serving != null && !_serving.IsCompleted && _bytesPerSecond == policy.BytesPerSecond && _bundleLimit == Settings.BundleLimitBytes && _slots == policy.Slots && (Object)(object)_network == (Object)(object)instance && _uploadMbps == Settings.DedicatedUploadMbps && _port == Settings.SharingPort && _facePort == Settings.FacePort && _bindAddress == Settings.SharingBindAddress && _dedicated == instance.IsDedicated())
			{
				return;
			}
			bool num = _serving?.IsFaulted ?? false;
			StopHost();
			if (num)
			{
				_nextCheck = Time.realtimeSinceStartup + 15f;
				Logger.LogOnce("sharing-listen-failed", "Cannot run embedded VRM TCP server. Check Sharing.BindAddress and ServerPort; retrying.");
				return;
			}
			_network = instance;
			_port = Settings.SharingPort;
			_facePort = Settings.FacePort;
			_bindAddress = Settings.SharingBindAddress;
			_dedicated = instance.IsDedicated();
			_bytesPerSecond = policy.BytesPerSecond;
			_slots = policy.Slots;
			_bundleLimit = Settings.BundleLimitBytes;
			_uploadMbps = Settings.DedicatedUploadMbps;
			_stop = new CancellationTokenSource();
			CancellationToken cancellation = _stop.Token;
			string bindAddress = _bindAddress;
			string path = Path.Combine(Constants.Vrm.Dir, "Server");
			int port = _port;
			int facePort = _facePor