using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.InputSystem.UI;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("DrawableSuits")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+4aec450a9737f33a67a55ab1962cf6ed017afa14")]
[assembly: AssemblyProduct("DrawableSuits")]
[assembly: AssemblyTitle("DrawableSuits")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace DrawableSuits
{
	internal static class DrawableSuitDesignCode
	{
		[Serializable]
		internal sealed class Payload
		{
			public int formatVersion;

			public string modVersion;

			public string designName;

			public string baseSuitName;

			public int sourceSuitId;

			public int width;

			public int height;

			public string exportedUtc;

			public string pngBase64;
		}

		internal struct CodeInfo
		{
			internal int FormatVersion;

			internal string DesignName;

			internal string BaseSuitName;

			internal int SourceSuitId;

			internal int Width;

			internal int Height;

			internal int PngBytes;

			internal int JsonBytes;

			internal int PayloadBytes;

			internal int CompressedBytes;

			internal int CodeLength;
		}

		internal const string PrefixV1 = "DSUIT1:";

		internal const string PrefixV2 = "DSUIT2:";

		internal const string Prefix = "DSUIT2:";

		private const int FormatVersionV1 = 1;

		private const int FormatVersionV2 = 2;

		private const int MaxDecodedJsonBytes = 25165824;

		private const int MaxDecodedBinaryBytes = 18874368;

		private const int MaxPngBytes = 16777216;

		internal static bool HasSupportedPrefix(string code)
		{
			if (string.IsNullOrWhiteSpace(code))
			{
				return false;
			}
			string text = code.TrimStart();
			if (!text.StartsWith("DSUIT2:", StringComparison.Ordinal))
			{
				return text.StartsWith("DSUIT1:", StringComparison.Ordinal);
			}
			return true;
		}

		internal static bool TryExport(SuitTextureState state, string designName, out string code, out CodeInfo info, out string failureReason)
		{
			code = string.Empty;
			info = default(CodeInfo);
			failureReason = string.Empty;
			if ((Object)(object)state?.EditableTexture == (Object)null)
			{
				failureReason = "No editable suit texture is available.";
				return false;
			}
			string text = TextureTools.SanitizeFileName(designName);
			if (string.IsNullOrWhiteSpace(text))
			{
				failureReason = "Design name is empty.";
				return false;
			}
			byte[] array = ImageConversion.EncodeToPNG(state.EditableTexture);
			if (array == null || array.Length == 0)
			{
				failureReason = "Failed to encode the editable texture.";
				return false;
			}
			if (array.Length > 16777216)
			{
				failureReason = $"Encoded texture is too large ({array.Length} bytes).";
				return false;
			}
			byte[] array2 = BuildV2PayloadBytes(text, state.SuitName ?? string.Empty, state.SuitId, ((Texture)state.EditableTexture).width, ((Texture)state.EditableTexture).height, DateTime.UtcNow.ToString("o"), array);
			byte[] array3 = Compress(array2);
			code = "DSUIT2:" + ToBase64Url(array3);
			info = new CodeInfo
			{
				FormatVersion = 2,
				DesignName = text,
				BaseSuitName = (state.SuitName ?? string.Empty),
				SourceSuitId = state.SuitId,
				Width = ((Texture)state.EditableTexture).width,
				Height = ((Texture)state.EditableTexture).height,
				PngBytes = array.Length,
				JsonBytes = 0,
				PayloadBytes = array2.Length,
				CompressedBytes = array3.Length,
				CodeLength = code.Length
			};
			return true;
		}

		internal static bool TryDecode(string code, int maxTextureSize, out Payload payload, out Texture2D texture, out CodeInfo info, out string failureReason)
		{
			payload = null;
			texture = null;
			info = default(CodeInfo);
			failureReason = string.Empty;
			if (string.IsNullOrWhiteSpace(code))
			{
				failureReason = "Design code is empty.";
				return false;
			}
			code = code.Trim();
			if (code.StartsWith("DSUIT2:", StringComparison.Ordinal))
			{
				return TryDecodeV2(code, maxTextureSize, out payload, out texture, out info, out failureReason);
			}
			if (code.StartsWith("DSUIT1:", StringComparison.Ordinal))
			{
				return TryDecodeV1(code, maxTextureSize, out payload, out texture, out info, out failureReason);
			}
			failureReason = "Design code must start with DSUIT2: or DSUIT1:";
			return false;
		}

		private static byte[] BuildV2PayloadBytes(string designName, string baseSuitName, int sourceSuitId, int width, int height, string exportedUtc, byte[] pngBytes)
		{
			using MemoryStream memoryStream = new MemoryStream();
			using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream, Encoding.UTF8, leaveOpen: true))
			{
				binaryWriter.Write(2);
				binaryWriter.Write("0.5.77");
				binaryWriter.Write(designName ?? string.Empty);
				binaryWriter.Write(baseSuitName ?? string.Empty);
				binaryWriter.Write(sourceSuitId);
				binaryWriter.Write(width);
				binaryWriter.Write(height);
				binaryWriter.Write(exportedUtc ?? string.Empty);
				binaryWriter.Write((pngBytes != null) ? pngBytes.Length : 0);
				if (pngBytes != null && pngBytes.Length != 0)
				{
					binaryWriter.Write(pngBytes);
				}
			}
			return memoryStream.ToArray();
		}

		private static bool TryDecodeV2(string code, int maxTextureSize, out Payload payload, out Texture2D texture, out CodeInfo info, out string failureReason)
		{
			payload = null;
			texture = null;
			info = default(CodeInfo);
			failureReason = string.Empty;
			byte[] array;
			try
			{
				array = FromBase64Url(RemoveWhitespace(code.Substring("DSUIT2:".Length)));
			}
			catch (Exception ex)
			{
				failureReason = "Design code is not valid Base64Url data (" + ex.GetType().Name + ").";
				return false;
			}
			byte[] array2;
			try
			{
				array2 = Decompress(array, 18874368);
			}
			catch (Exception ex2)
			{
				failureReason = "Design code payload could not be decompressed (" + ex2.GetType().Name + ").";
				return false;
			}
			byte[] array3;
			try
			{
				using MemoryStream memoryStream = new MemoryStream(array2);
				using BinaryReader binaryReader = new BinaryReader(memoryStream, Encoding.UTF8);
				int num = binaryReader.ReadInt32();
				if (num != 2)
				{
					failureReason = $"Unsupported design code format {num}.";
					return false;
				}
				payload = new Payload
				{
					formatVersion = num,
					modVersion = binaryReader.ReadString(),
					designName = binaryReader.ReadString(),
					baseSuitName = binaryReader.ReadString(),
					sourceSuitId = binaryReader.ReadInt32(),
					width = binaryReader.ReadInt32(),
					height = binaryReader.ReadInt32(),
					exportedUtc = binaryReader.ReadString(),
					pngBase64 = string.Empty
				};
				int num2 = binaryReader.ReadInt32();
				if (num2 <= 0)
				{
					failureReason = "Design code PNG data is empty.";
					return false;
				}
				if (num2 > 16777216)
				{
					failureReason = $"Design code PNG data is too large ({num2} bytes).";
					return false;
				}
				if (memoryStream.Length - memoryStream.Position < num2)
				{
					failureReason = "Design code PNG data is truncated.";
					return false;
				}
				array3 = binaryReader.ReadBytes(num2);
				if (array3.Length != num2)
				{
					failureReason = "Design code PNG data is truncated.";
					return false;
				}
			}
			catch (Exception ex3)
			{
				payload = null;
				failureReason = "Design code binary payload could not be parsed (" + ex3.GetType().Name + ").";
				return false;
			}
			return TryLoadDecodedTexture(code, maxTextureSize, payload, array3, array2.Length, 0, array.Length, out texture, out info, out failureReason);
		}

		private static bool TryDecodeV1(string code, int maxTextureSize, out Payload payload, out Texture2D texture, out CodeInfo info, out string failureReason)
		{
			payload = null;
			texture = null;
			info = default(CodeInfo);
			failureReason = string.Empty;
			byte[] array;
			try
			{
				array = FromBase64Url(RemoveWhitespace(code.Substring("DSUIT1:".Length)));
			}
			catch (Exception ex)
			{
				failureReason = "Design code is not valid Base64Url data (" + ex.GetType().Name + ").";
				return false;
			}
			byte[] array2;
			try
			{
				array2 = Decompress(array, 25165824);
			}
			catch (Exception ex2)
			{
				failureReason = "Design code payload could not be decompressed (" + ex2.GetType().Name + ").";
				return false;
			}
			try
			{
				payload = JsonUtility.FromJson<Payload>(Encoding.UTF8.GetString(array2));
			}
			catch (Exception ex3)
			{
				failureReason = "Design code JSON could not be parsed (" + ex3.GetType().Name + ").";
				return false;
			}
			if (payload == null)
			{
				failureReason = "Design code payload is missing.";
				return false;
			}
			if (payload.formatVersion != 1)
			{
				failureReason = $"Unsupported design code format {payload.formatVersion}.";
				return false;
			}
			if (string.IsNullOrWhiteSpace(payload.pngBase64))
			{
				failureReason = "Design code is missing PNG data.";
				return false;
			}
			byte[] pngBytes;
			try
			{
				pngBytes = Convert.FromBase64String(payload.pngBase64);
			}
			catch (Exception ex4)
			{
				failureReason = "Design code PNG data is invalid (" + ex4.GetType().Name + ").";
				return false;
			}
			return TryLoadDecodedTexture(code, maxTextureSize, payload, pngBytes, 0, array2.Length, array.Length, out texture, out info, out failureReason);
		}

		private static bool TryLoadDecodedTexture(string code, int maxTextureSize, Payload payload, byte[] pngBytes, int payloadBytes, int jsonBytes, int compressedBytes, out Texture2D texture, out CodeInfo info, out string failureReason)
		{
			texture = null;
			info = default(CodeInfo);
			failureReason = string.Empty;
			if (payload == null)
			{
				failureReason = "Design code payload is missing.";
				return false;
			}
			if (string.IsNullOrWhiteSpace(payload.designName))
			{
				failureReason = "Design code is missing a design name.";
				return false;
			}
			if (payload.width <= 0 || payload.height <= 0)
			{
				failureReason = "Design code has invalid texture dimensions.";
				return false;
			}
			if (payload.width > maxTextureSize || payload.height > maxTextureSize)
			{
				failureReason = $"Design code texture is too large ({payload.width}x{payload.height}, max {maxTextureSize}).";
				return false;
			}
			if (pngBytes == null || pngBytes.Length == 0)
			{
				failureReason = "Design code PNG data is empty.";
				return false;
			}
			if (pngBytes.Length > 16777216)
			{
				failureReason = $"Design code PNG data is too large ({pngBytes.Length} bytes).";
				return false;
			}
			texture = TextureTools.LoadImageBytes(pngBytes, "DrawableSuitsDesignCodeTexture", maxTextureSize, resizeOversized: false);
			if ((Object)(object)texture == (Object)null)
			{
				failureReason = $"Design code PNG data could not be loaded as an image or exceeds max size {maxTextureSize}.";
				return false;
			}
			if (((Texture)texture).width > maxTextureSize || ((Texture)texture).height > maxTextureSize)
			{
				int width = ((Texture)texture).width;
				int height = ((Texture)texture).height;
				Object.Destroy((Object)(object)texture);
				texture = null;
				failureReason = $"Decoded texture is too large ({width}x{height}, max {maxTextureSize}).";
				return false;
			}
			info = new CodeInfo
			{
				FormatVersion = payload.formatVersion,
				DesignName = payload.designName,
				BaseSuitName = payload.baseSuitName,
				SourceSuitId = payload.sourceSuitId,
				Width = ((Texture)texture).width,
				Height = ((Texture)texture).height,
				PngBytes = pngBytes.Length,
				JsonBytes = jsonBytes,
				PayloadBytes = payloadBytes,
				CompressedBytes = compressedBytes,
				CodeLength = code.Length
			};
			return true;
		}

		private static byte[] Compress(byte[] bytes)
		{
			using MemoryStream memoryStream = new MemoryStream();
			using (GZipStream gZipStream = new GZipStream(memoryStream, CompressionMode.Compress, leaveOpen: true))
			{
				gZipStream.Write(bytes, 0, bytes.Length);
			}
			return memoryStream.ToArray();
		}

		private static byte[] Decompress(byte[] bytes, int maxBytes)
		{
			using MemoryStream stream = new MemoryStream(bytes);
			using GZipStream gZipStream = new GZipStream(stream, CompressionMode.Decompress);
			using MemoryStream memoryStream = new MemoryStream();
			byte[] array = new byte[8192];
			int num;
			while ((num = gZipStream.Read(array, 0, array.Length)) > 0)
			{
				if (memoryStream.Length + num > maxBytes)
				{
					throw new InvalidDataException("Decoded payload exceeds the maximum allowed size.");
				}
				memoryStream.Write(array, 0, num);
			}
			return memoryStream.ToArray();
		}

		private static string ToBase64Url(byte[] bytes)
		{
			return Convert.ToBase64String(bytes).TrimEnd('=').Replace('+', '-')
				.Replace('/', '_');
		}

		private static byte[] FromBase64Url(string value)
		{
			value = value.Replace('-', '+').Replace('_', '/');
			switch (value.Length % 4)
			{
			case 2:
				value += "==";
				break;
			case 3:
				value += "=";
				break;
			default:
				throw new FormatException("Invalid Base64Url padding.");
			case 0:
				break;
			}
			return Convert.FromBase64String(value);
		}

		private static string RemoveWhitespace(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder(value.Length);
			for (int i = 0; i < value.Length; i++)
			{
				if (!char.IsWhiteSpace(value[i]))
				{
					stringBuilder.Append(value[i]);
				}
			}
			return stringBuilder.ToString();
		}
	}
	internal sealed class DrawableSuitsConfig
	{
		public ConfigEntry<KeyCode> OpenEditorKey { get; }

		public ConfigEntry<KeyCode> EmergencyOpenKey { get; }

		public ConfigEntry<int> MaxTextureSize { get; }

		public ConfigEntry<int> MaxUndoStates { get; }

		public ConfigEntry<int> MaxSyncBytes { get; }

		public ConfigEntry<int> SyncChunkBytes { get; }

		public ConfigEntry<float> ControllerCursorSpeed { get; }

		public ConfigEntry<bool> EnableNetworkSync { get; }

		public ConfigEntry<bool> EnableExperimentalModelPreview { get; }

		public ConfigEntry<bool> StartInUvFallbackMode { get; }

		public ConfigEntry<float> ThirdPersonCameraDistance { get; }

		public ConfigEntry<string> RecentColors { get; }

		public ConfigEntry<bool> ApplyLocalFirstPersonArms { get; }

		public DrawableSuitsConfig(ConfigFile config)
		{
			OpenEditorKey = config.Bind<KeyCode>("Input", "OpenEditorKey", (KeyCode)289, "Keyboard key that opens or closes the suit editor.");
			EmergencyOpenKey = config.Bind<KeyCode>("Input", "EmergencyOpenKey", (KeyCode)291, "Keyboard key that opens the editor even when suit/player detection is incomplete.");
			ControllerCursorSpeed = config.Bind<float>("Input", "ControllerCursorSpeed", 900f, "Virtual cursor speed in pixels per second.");
			MaxTextureSize = config.Bind<int>("Textures", "MaxTextureSize", 1024, "Maximum width and height for editable and synced suit textures.");
			MaxUndoStates = config.Bind<int>("Editor", "MaxUndoStates", 12, "Maximum undo snapshots kept while editing.");
			EnableNetworkSync = config.Bind<bool>("Multiplayer", "EnableNetworkSync", true, "Sync applied and saved suit designs to other DrawableSuits users.");
			MaxSyncBytes = config.Bind<int>("Multiplayer", "MaxSyncBytes", 4194304, "Maximum PNG payload size allowed for multiplayer sync.");
			SyncChunkBytes = config.Bind<int>("Multiplayer", "SyncChunkBytes", 48000, "Byte size for each Netcode custom-message texture chunk.");
			EnableExperimentalModelPreview = config.Bind<bool>("Editor", "EnableExperimentalModelPreview", false, "Disabled by default. Uses the old camera/RenderTexture 3D model preview only for diagnostics; third-person world painting is the default.");
			StartInUvFallbackMode = config.Bind<bool>("Editor", "StartInUvFallbackMode", false, "Open directly into the old UV texture fallback instead of third-person world painting. Useful for diagnostics.");
			ThirdPersonCameraDistance = config.Bind<float>("Editor", "ThirdPersonCameraDistance", 3.4f, "Default third-person editor camera orbit distance.");
			RecentColors = config.Bind<string>("Editor", "RecentColors", string.Empty, "Recent brush colors as comma-separated #RRGGBB values. Colors are added only after Paint, Fill, or Text writes to the suit.");
			ApplyLocalFirstPersonArms = config.Bind<bool>("Compatibility", "ApplyLocalFirstPersonArms", false, "Experimental. When false, DrawableSuits does not apply edited materials to the local first-person arms/body outside the editor.");
		}
	}
	internal static class DrawableSuitsDiagnostics
	{
		private static readonly object SyncRoot = new object();

		private static string _logPath;

		private static bool _initialized;

		public static string LogPath => _logPath ?? Path.Combine(DrawableSuitsPaths.Logs, "diagnostics.log");

		public static void Initialize()
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				DrawableSuitsPaths.EnsureCreated();
				_logPath = Path.Combine(DrawableSuitsPaths.Logs, "diagnostics.log");
				Directory.CreateDirectory(Path.GetDirectoryName(_logPath));
				File.WriteAllText(_logPath, string.Empty);
				_initialized = true;
				Info("Diagnostics initialized.");
				Info("DrawableSuits 0.5.77 (com.toxcgang.drawablesuits) starting.");
				Info($"UnityVersion={Application.unityVersion}; ApplicationVersion={Application.version}; Platform={Application.platform}; ProductName={Application.productName}");
				Info("DataPath=" + Application.dataPath + "; PersistentDataPath=" + Application.persistentDataPath + "; ConfigRoot=" + DrawableSuitsPaths.Root);
				Scene activeScene = SceneManager.GetActiveScene();
				string name = ((Scene)(ref activeScene)).name;
				activeScene = SceneManager.GetActiveScene();
				Info($"ActiveScene={name}; SceneBuildIndex={((Scene)(ref activeScene)).buildIndex}");
				AssemblyName[] referencedAssemblies = Assembly.GetExecutingAssembly().GetReferencedAssemblies();
				foreach (AssemblyName assemblyName in referencedAssemblies)
				{
					Info($"Reference={assemblyName.Name}, Version={assemblyName.Version}");
				}
			}
			catch (Exception arg)
			{
				_initialized = false;
				LogToBepInEx((LogLevel)2, $"DrawableSuits diagnostics failed to initialize: {arg}");
			}
		}

		public static void Info(string message)
		{
			Write((LogLevel)16, message);
		}

		public static void Warn(string message)
		{
			Write((LogLevel)4, message);
		}

		public static void Error(string message)
		{
			Write((LogLevel)2, message);
		}

		public static void Exception(string context, Exception exception)
		{
			if (exception == null)
			{
				Error(context + ": unknown exception.");
				return;
			}
			Write((LogLevel)2, context + ": " + exception.GetType().FullName + ": " + exception.Message + Environment.NewLine + exception.StackTrace);
		}

		private static void Write(LogLevel level, string message)
		{
			//IL_000f: 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)
			string text = $"[{DateTime.Now:O}] [{level}] {message ?? string.Empty}";
			LogToBepInEx(level, message ?? string.Empty);
			if (!_initialized)
			{
				return;
			}
			try
			{
				lock (SyncRoot)
				{
					File.AppendAllText(LogPath, text + Environment.NewLine);
				}
			}
			catch
			{
			}
		}

		private static void LogToBepInEx(LogLevel level, string message)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Invalid comparison between Unknown and I4
			ManualLogSource modLogger = DrawableSuitsPlugin.ModLogger;
			if (modLogger == null)
			{
				Debug.Log((object)("[DrawableSuits] " + message));
			}
			else if ((int)level != 2)
			{
				if ((int)level != 4)
				{
					if ((int)level == 32)
					{
						modLogger.LogDebug((object)message);
					}
					else
					{
						modLogger.LogInfo((object)message);
					}
				}
				else
				{
					modLogger.LogWarning((object)message);
				}
			}
			else
			{
				modLogger.LogError((object)message);
			}
		}
	}
	internal static class DrawableSuitsInput
	{
		private static bool _legacyUnavailable;

		private static bool _legacyUnavailableLogged;

		internal static bool WasKeyPressed(Key defaultKey, KeyCode configuredKey)
		{
			//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)
			//IL_0016: 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)
			Key key = MapKeyCode(configuredKey, defaultKey);
			if (Keyboard.current != null)
			{
				return WasInputSystemKeyPressed(key);
			}
			return WasLegacyKeyPressedOnceGuarded(configuredKey);
		}

		internal static bool WasKeyPressed(Key key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return WasInputSystemKeyPressed(key);
		}

		internal static bool IsKeyPressed(Key key)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Keyboard current = Keyboard.current;
				return current != null && ((ButtonControl)current[key]).isPressed;
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception($"Input System key held polling failed for {key}", exception);
				return false;
			}
		}

		internal static bool TryGetMousePosition(out Vector2 position)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Mouse current = Mouse.current;
				if (current != null)
				{
					position = ((InputControl<Vector2>)(object)((Pointer)current).position).ReadValue();
					return true;
				}
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception("Input System mouse position polling failed", exception);
			}
			position = default(Vector2);
			return false;
		}

		internal static bool IsLeftMousePressed()
		{
			return IsMouseButtonPressed((Mouse mouse) => mouse.leftButton.isPressed, "left");
		}

		internal static bool IsRightMousePressed()
		{
			return IsMouseButtonPressed((Mouse mouse) => mouse.rightButton.isPressed, "right");
		}

		internal static float MouseDeltaX()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Mouse current = Mouse.current;
				return (current != null) ? ((InputControl<Vector2>)(object)((Pointer)current).delta).ReadValue().x : 0f;
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception("Input System mouse delta polling failed", exception);
				return 0f;
			}
		}

		internal static float MouseDeltaY()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Mouse current = Mouse.current;
				return (current != null) ? ((InputControl<Vector2>)(object)((Pointer)current).delta).ReadValue().y : 0f;
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception("Input System mouse delta polling failed", exception);
				return 0f;
			}
		}

		internal static bool WasMouseUsedThisFrame()
		{
			//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_0047: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Mouse current = Mouse.current;
				if (current == null)
				{
					return false;
				}
				Vector2 val = ((InputControl<Vector2>)(object)((Pointer)current).delta).ReadValue();
				return ((Vector2)(ref val)).sqrMagnitude > 0.01f || current.leftButton.isPressed || current.rightButton.isPressed || Mathf.Abs(((InputControl<Vector2>)(object)current.scroll).ReadValue().y) > 0.01f;
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception("Input System mouse activity polling failed", exception);
				return false;
			}
		}

		internal static float MouseScrollY()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Mouse current = Mouse.current;
				if (current == null)
				{
					return 0f;
				}
				float y = ((InputControl<Vector2>)(object)current.scroll).ReadValue().y;
				return (Mathf.Abs(y) > 10f) ? (y / 120f) : y;
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception("Input System mouse scroll polling failed", exception);
				return 0f;
			}
		}

		private static bool IsMouseButtonPressed(Func<Mouse, bool> accessor, string buttonName)
		{
			try
			{
				Mouse current = Mouse.current;
				return current != null && accessor(current);
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception("Input System " + buttonName + " mouse button polling failed", exception);
				return false;
			}
		}

		private static bool WasInputSystemKeyPressed(Key key)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Keyboard current = Keyboard.current;
				return current != null && ((ButtonControl)current[key]).wasPressedThisFrame;
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception($"Input System key polling failed for {key}", exception);
				return false;
			}
		}

		private static bool WasLegacyKeyPressedOnceGuarded(KeyCode key)
		{
			//IL_004c: 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_000a: Unknown result type (might be due to invalid IL or missing references)
			if (_legacyUnavailable)
			{
				return false;
			}
			try
			{
				return Input.GetKeyDown(key);
			}
			catch (InvalidOperationException ex)
			{
				_legacyUnavailable = true;
				if (!_legacyUnavailableLogged)
				{
					_legacyUnavailableLogged = true;
					DrawableSuitsDiagnostics.Warn($"Legacy UnityEngine.Input is disabled; using Unity Input System only. First legacy failure for {key}: {ex.Message}");
				}
				return false;
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception($"Legacy key polling failed once for {key}", exception);
				return false;
			}
		}

		private unsafe static Key MapKeyCode(KeyCode keyCode, Key fallback)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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)
			if (TryMapSpecialKey(keyCode, out var key))
			{
				return key;
			}
			if (Enum.TryParse<Key>(((object)(*(KeyCode*)(&keyCode))/*cast due to .constrained prefix*/).ToString(), ignoreCase: true, out key))
			{
				return key;
			}
			return fallback;
		}

		private static bool TryMapSpecialKey(KeyCode keyCode, out Key key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Invalid comparison between Unknown and I4
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Invalid comparison between Unknown and I4
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Invalid comparison between Unknown and I4
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_007e: 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_00ae: Expected I4, but got Unknown
			//IL_0040: 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_0071: Expected I4, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected I4, but got Unknown
			if ((int)keyCode <= 27)
			{
				if ((int)keyCode <= 9)
				{
					if ((int)keyCode == 8)
					{
						key = (Key)65;
						return true;
					}
					if ((int)keyCode == 9)
					{
						key = (Key)3;
						return true;
					}
				}
				else
				{
					if ((int)keyCode == 13)
					{
						key = (Key)2;
						return true;
					}
					if ((int)keyCode == 27)
					{
						key = (Key)60;
						return true;
					}
				}
			}
			else if ((int)keyCode <= 57)
			{
				if ((int)keyCode == 32)
				{
					key = (Key)1;
					return true;
				}
				switch (keyCode - 48)
				{
				case 0:
					key = (Key)50;
					return true;
				case 1:
					key = (Key)41;
					return true;
				case 2:
					key = (Key)42;
					return true;
				case 3:
					key = (Key)43;
					return true;
				case 4:
					key = (Key)44;
					return true;
				case 5:
					key = (Key)45;
					return true;
				case 6:
					key = (Key)46;
					return true;
				case 7:
					key = (Key)47;
					return true;
				case 8:
					key = (Key)48;
					return true;
				case 9:
					key = (Key)49;
					return true;
				}
			}
			else
			{
				if ((int)keyCode == 127)
				{
					key = (Key)71;
					return true;
				}
				switch (keyCode - 273)
				{
				case 0:
					key = (Key)63;
					return true;
				case 1:
					key = (Key)64;
					return true;
				case 3:
					key = (Key)61;
					return true;
				case 2:
					key = (Key)62;
					return true;
				case 4:
					key = (Key)70;
					return true;
				case 5:
					key = (Key)68;
					return true;
				case 6:
					key = (Key)69;
					return true;
				case 7:
					key = (Key)67;
					return true;
				case 8:
					key = (Key)66;
					return true;
				}
				switch (keyCode - 303)
				{
				case 1:
					key = (Key)51;
					return true;
				case 0:
					key = (Key)52;
					return true;
				case 3:
					key = (Key)55;
					return true;
				case 2:
					key = (Key)56;
					return true;
				case 5:
					key = (Key)53;
					return true;
				case 4:
					key = (Key)54;
					return true;
				}
			}
			key = (Key)0;
			return false;
		}
	}
	internal static class DrawableSuitsPaths
	{
		public static string Root => Path.Combine(Paths.ConfigPath, "DrawableSuits");

		public static string Saves => Path.Combine(Root, "Saves");

		public static string Textures => Path.Combine(Root, "Textures");

		public static string Decals => Path.Combine(Root, "Decals");

		public static string Logs => Path.Combine(Root, "Logs");

		public static void EnsureCreated()
		{
			Directory.CreateDirectory(Root);
			Directory.CreateDirectory(Saves);
			Directory.CreateDirectory(Textures);
			Directory.CreateDirectory(Decals);
			Directory.CreateDirectory(Logs);
		}
	}
	[BepInPlugin("com.toxcgang.drawablesuits", "DrawableSuits", "0.5.77")]
	[BepInProcess("Lethal Company.exe")]
	public sealed class DrawableSuitsPlugin : BaseUnityPlugin
	{
		private static GameObject _runtimeRoot;

		private Harmony _harmony;

		internal static DrawableSuitsPlugin Instance { get; private set; }

		internal static ManualLogSource ModLogger { get; private set; }

		internal static DrawableSuitsConfig ModConfig { get; private set; }

		internal static SuitTextureRegistry Registry { get; private set; }

		internal static SuitEditorController Editor { get; private set; }

		internal static DrawableSuitsRuntimeHost RuntimeHost { get; private set; }

		internal static SuitSyncManager Sync { get; private set; }

		internal static bool IsEditorOpen
		{
			get
			{
				if ((Object)(object)Editor != (Object)null)
				{
					return Editor.IsOpenForDiagnostics;
				}
				return false;
			}
		}

		private void Awake()
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Expected O, but got Unknown
			Instance = this;
			ModLogger = ((BaseUnityPlugin)this).Logger;
			ModConfig = new DrawableSuitsConfig(((BaseUnityPlugin)this).Config);
			DrawableSuitsPaths.EnsureCreated();
			DrawableSuitsDiagnostics.Initialize();
			string[] obj = new string[6]
			{
				"Plugin Awake. pluginInstance=",
				DescribeUnityObject((Object)(object)this),
				"; pluginGameObject=",
				DescribeUnityObject((Object)(object)((Component)this).gameObject),
				"; scene=",
				null
			};
			Scene activeScene = SceneManager.GetActiveScene();
			obj[5] = ((Scene)(ref activeScene)).name;
			DrawableSuitsDiagnostics.Info(string.Concat(obj));
			DrawableSuitsDiagnostics.Info($"Config OpenEditorKey={ModConfig.OpenEditorKey.Value}; EmergencyOpenKey={ModConfig.EmergencyOpenKey.Value}; ControllerCursorSpeed={ModConfig.ControllerCursorSpeed.Value}; MaxTextureSize={ModConfig.MaxTextureSize.Value}; MaxUndoStates={ModConfig.MaxUndoStates.Value}; NetworkSync={ModConfig.EnableNetworkSync.Value}; MaxSyncBytes={ModConfig.MaxSyncBytes.Value}; SyncChunkBytes={ModConfig.SyncChunkBytes.Value}; ExperimentalModelPreview={ModConfig.EnableExperimentalModelPreview.Value}; StartInUvFallbackMode={ModConfig.StartInUvFallbackMode.Value}; ThirdPersonCameraDistance={ModConfig.ThirdPersonCameraDistance.Value}; ApplyLocalFirstPersonArms={ModConfig.ApplyLocalFirstPersonArms.Value}");
			_harmony = new Harmony("com.toxcgang.drawablesuits");
			try
			{
				DrawableSuitsDiagnostics.Info("Applying Harmony patches.");
				_harmony.PatchAll();
				PlayerControllerBPatches.ApplyOptionalGameplayInputPatches(_harmony);
				DrawableSuitsDiagnostics.Info("Harmony patches applied.");
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception("Harmony PatchAll failed", exception);
				throw;
			}
			SceneManager.sceneLoaded += OnSceneLoaded;
			EnsureRuntimeReady("Plugin.Awake");
			DrawableSuitsDiagnostics.Info("DrawableSuits 0.5.77 loaded with GUID com.toxcgang.drawablesuits.");
		}

		private void Start()
		{
			DrawableSuitsDiagnostics.Info("Plugin Start. plugin=" + DescribeUnityObject((Object)(object)this) + "; host=" + DescribeUnityObject((Object)(object)RuntimeHost) + "; editor=" + DescribeUnityObject((Object)(object)Editor));
			EnsureRuntimeReady("Plugin.Start");
			SessionSafetyGuard.Run("Plugin.Start", forceLog: true);
		}

		private void Update()
		{
			EnsureRuntimeReady("Plugin.Update");
		}

		private void OnDestroy()
		{
			DrawableSuitsDiagnostics.Info("DrawableSuitsPlugin.OnDestroy called.");
			if ((Object)(object)Editor != (Object)null && Editor.IsOpenForDiagnostics)
			{
				Editor.CloseEditorForPluginDestroy();
			}
			SceneManager.sceneLoaded -= OnSceneLoaded;
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			Registry = null;
			Sync = null;
			Editor = null;
			RuntimeHost = null;
			if ((Object)(object)_runtimeRoot != (Object)null)
			{
				Object.Destroy((Object)(object)_runtimeRoot);
				_runtimeRoot = null;
			}
			if (Instance == this)
			{
				Instance = null;
			}
		}

		private static void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			//IL_0018: 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_0029: 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)
			DrawableSuitsDiagnostics.Info($"Scene loaded. name={((Scene)(ref scene)).name}; buildIndex={((Scene)(ref scene)).buildIndex}; mode={mode}");
			bool num = ShouldCloseEditorForScene(scene, mode);
			EnsureRuntimeReady("SceneLoaded:" + ((Scene)(ref scene)).name);
			if (num && (Object)(object)Editor != (Object)null && Editor.IsOpenForDiagnostics)
			{
				DrawableSuitsDiagnostics.Info($"Closing editor because scene changed to '{((Scene)(ref scene)).name}' with mode={mode}.");
				Editor.CloseEditorForSceneChange();
			}
			Registry?.ReapplyAllIfReady("SceneLoaded:" + ((Scene)(ref scene)).name);
			SessionSafetyGuard.Run("SceneLoaded:" + ((Scene)(ref scene)).name, forceLog: true);
		}

		internal static bool HasSessionSafetyContext()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			if (!((Object)(object)StartOfRound.Instance != (Object)null) && !((Object)(object)Object.FindObjectOfType<GameNetworkManager>()?.localPlayerController != (Object)null))
			{
				return string.Equals(name, "SampleSceneRelay", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		internal static bool HasGameplayEditorContext()
		{
			if ((Object)(object)StartOfRound.Instance?.localPlayerController != (Object)null)
			{
				return (Object)(object)Camera.main != (Object)null;
			}
			return false;
		}

		private static bool ShouldCloseEditorForScene(Scene scene, LoadSceneMode mode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			if ((int)mode != 1)
			{
				return true;
			}
			if (!string.Equals(((Scene)(ref scene)).name, "MainMenu", StringComparison.OrdinalIgnoreCase) && !string.Equals(((Scene)(ref scene)).name, "InitScene", StringComparison.OrdinalIgnoreCase))
			{
				return string.Equals(((Scene)(ref scene)).name, "InitSceneLaunchOptions", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		internal static bool EnsureRuntimeReady(string reason)
		{
			if ((Object)(object)Instance == (Object)null)
			{
				DrawableSuitsDiagnostics.Warn("EnsureRuntimeReady(" + reason + ") failed: plugin instance is null.");
				return false;
			}
			GameObject orCreateRuntimeRoot = GetOrCreateRuntimeRoot(reason);
			if ((Object)(object)orCreateRuntimeRoot == (Object)null)
			{
				DrawableSuitsDiagnostics.Warn("EnsureRuntimeReady(" + reason + ") failed: runtime root is null.");
				return false;
			}
			Registry = EnsureComponent<SuitTextureRegistry>(Registry, orCreateRuntimeRoot, reason, "registry");
			Sync = EnsureComponent<SuitSyncManager>(Sync, orCreateRuntimeRoot, reason, "sync");
			Editor = EnsureComponent<SuitEditorController>(Editor, orCreateRuntimeRoot, reason, "editor");
			RuntimeHost = EnsureComponent<DrawableSuitsRuntimeHost>(RuntimeHost, orCreateRuntimeRoot, reason, "runtime host");
			bool flag = (Object)(object)Registry != (Object)null && (Object)(object)Sync != (Object)null && (Object)(object)Editor != (Object)null && (Object)(object)RuntimeHost != (Object)null;
			if (!flag)
			{
				DrawableSuitsDiagnostics.Warn("EnsureRuntimeReady(" + reason + ") incomplete. registry=" + DescribeUnityObject((Object)(object)Registry) + "; sync=" + DescribeUnityObject((Object)(object)Sync) + "; editor=" + DescribeUnityObject((Object)(object)Editor) + "; host=" + DescribeUnityObject((Object)(object)RuntimeHost));
			}
			return flag;
		}

		private static GameObject GetOrCreateRuntimeRoot(string reason)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			if ((Object)(object)_runtimeRoot != (Object)null)
			{
				return _runtimeRoot;
			}
			_runtimeRoot = new GameObject("DrawableSuitsRuntimeRoot");
			((Object)_runtimeRoot).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)(object)_runtimeRoot);
			DrawableSuitsDiagnostics.Info("Runtime root created. reason=" + reason + "; root=" + DescribeUnityObject((Object)(object)_runtimeRoot));
			return _runtimeRoot;
		}

		internal static bool RequestOpenEditor(string source)
		{
			bool flag = EnsureRuntimeReady("RequestOpenEditor:" + source);
			DrawableSuitsDiagnostics.Info($"RequestOpenEditor source={source}; runtimeReady={flag}; editor={DescribeUnityObject((Object)(object)Editor)}");
			if (!flag || (Object)(object)Editor == (Object)null)
			{
				return false;
			}
			bool flag2 = Editor.OpenEditor(source);
			DrawableSuitsDiagnostics.Info($"RequestOpenEditor result source={source}; opened={flag2}; editorOpen={Editor.IsOpenForDiagnostics}; canvasActive={Editor.CanvasActiveForDiagnostics}");
			return flag2;
		}

		internal static bool RequestToggleEditor(string source)
		{
			bool flag = EnsureRuntimeReady("RequestToggleEditor:" + source);
			DrawableSuitsDiagnostics.Info($"RequestToggleEditor source={source}; runtimeReady={flag}; editor={DescribeUnityObject((Object)(object)Editor)}");
			if (!flag || (Object)(object)Editor == (Object)null)
			{
				return false;
			}
			if (!Editor.IsOpenForDiagnostics)
			{
				return RequestOpenEditor(source);
			}
			return CloseEditor(source);
		}

		internal static bool CloseEditor(string source)
		{
			EnsureRuntimeReady("CloseEditor:" + source);
			if ((Object)(object)Editor == (Object)null)
			{
				DrawableSuitsDiagnostics.Warn("CloseEditor source=" + source + " ignored because editor is null.");
				return false;
			}
			DrawableSuitsDiagnostics.Info("CloseEditor source=" + source + "; editor=" + DescribeUnityObject((Object)(object)Editor));
			Editor.CloseEditor(source);
			return true;
		}

		internal static string DescribeUnityObject(Object unityObject)
		{
			if (unityObject == (Object)null)
			{
				return "null";
			}
			return $"{((object)unityObject).GetType().Name}(id={unityObject.GetInstanceID()}, name={unityObject.name})";
		}

		private static T EnsureComponent<T>(T current, GameObject hostObject, string reason, string label) where T : Component
		{
			if ((Object)(object)current != (Object)null)
			{
				return current;
			}
			T component = hostObject.GetComponent<T>();
			if ((Object)(object)component != (Object)null)
			{
				DrawableSuitsDiagnostics.Info("EnsureRuntimeReady(" + reason + ") recovered existing " + label + ": " + DescribeUnityObject((Object)(object)component));
				return component;
			}
			T val = hostObject.AddComponent<T>();
			DrawableSuitsDiagnostics.Info("EnsureRuntimeReady(" + reason + ") created " + label + ": " + DescribeUnityObject((Object)(object)val) + " on " + DescribeUnityObject((Object)(object)hostObject));
			return val;
		}
	}
	internal sealed class DrawableSuitsRuntimeHost : MonoBehaviour
	{
		private bool _firstUpdateLogged;

		private bool _controllerOpenChordWasHeld;

		private void Awake()
		{
			DrawableSuitsDiagnostics.Info("RuntimeHost Awake. host=" + DrawableSuitsPlugin.DescribeUnityObject((Object)(object)this) + "; gameObject=" + DrawableSuitsPlugin.DescribeUnityObject((Object)(object)((Component)this).gameObject));
		}

		private void Start()
		{
			DrawableSuitsDiagnostics.Info("RuntimeHost Start. editor=" + DrawableSuitsPlugin.DescribeUnityObject((Object)(object)DrawableSuitsPlugin.Editor));
		}

		private void Update()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (!_firstUpdateLogged)
			{
				_firstUpdateLogged = true;
				object arg = Time.frameCount;
				Scene activeScene = SceneManager.GetActiveScene();
				DrawableSuitsDiagnostics.Info($"RuntimeHost first Update. frame={arg}; scene={((Scene)(ref activeScene)).name}; editor={DrawableSuitsPlugin.DescribeUnityObject((Object)(object)DrawableSuitsPlugin.Editor)}");
			}
			DrawableSuitsPlugin.EnsureRuntimeReady("RuntimeHost.Update");
			HandleInput();
		}

		private void HandleInput()
		{
			//IL_000c: 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)
			if (DrawableSuitsInput.WasKeyPressed((Key)103, DrawableSuitsPlugin.ModConfig.EmergencyOpenKey.Value))
			{
				DrawableSuitsDiagnostics.Info("RuntimeHost F10 emergency open. editor=" + DrawableSuitsPlugin.DescribeUnityObject((Object)(object)DrawableSuitsPlugin.Editor));
				DrawableSuitsPlugin.RequestOpenEditor("F10Emergency");
			}
			if (DrawableSuitsInput.WasKeyPressed((Key)101, DrawableSuitsPlugin.ModConfig.OpenEditorKey.Value))
			{
				DrawableSuitsDiagnostics.Info("RuntimeHost F8 toggle. editor=" + DrawableSuitsPlugin.DescribeUnityObject((Object)(object)DrawableSuitsPlugin.Editor));
				RequestGameplayToggle("F8Keyboard");
			}
			if (WasControllerOpenChordPressed())
			{
				DrawableSuitsDiagnostics.Info("RuntimeHost controller open chord. editor=" + DrawableSuitsPlugin.DescribeUnityObject((Object)(object)DrawableSuitsPlugin.Editor));
				RequestGameplayToggle("ControllerViewBackY");
			}
		}

		private static void RequestGameplayToggle(string source)
		{
			SuitEditorController editor = DrawableSuitsPlugin.Editor;
			if (editor != null && editor.IsOpenForDiagnostics)
			{
				DrawableSuitsPlugin.RequestToggleEditor(source);
			}
			else if (!DrawableSuitsPlugin.HasGameplayEditorContext())
			{
				DrawableSuitsDiagnostics.Info("RuntimeHost ignored " + source + " open because no gameplay player/camera context is available. Use F10 for diagnostics.");
			}
			else
			{
				DrawableSuitsPlugin.RequestToggleEditor(source);
			}
		}

		private bool WasControllerOpenChordPressed()
		{
			Gamepad current = Gamepad.current;
			if (current == null)
			{
				_controllerOpenChordWasHeld = false;
				return false;
			}
			ButtonControl val = current.selectButton ?? ((InputControl)current).TryGetChildControl<ButtonControl>("backButton");
			bool flag = val != null && val.isPressed && current.buttonNorth.isPressed;
			bool result = flag && !_controllerOpenChordWasHeld;
			_controllerOpenChordWasHeld = flag;
			return result;
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal static class StartOfRoundPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("LoadUnlockables")]
		private static void LoadUnlockablesPostfix()
		{
			RunPatch("StartOfRound.LoadUnlockables", delegate
			{
				DrawableSuitsPlugin.Registry?.ReapplyAllIfReady("StartOfRound.LoadUnlockables");
				SessionSafetyGuard.Run("StartOfRound.LoadUnlockables", forceLog: true);
			});
		}

		[HarmonyPostfix]
		[HarmonyPatch("PositionSuitsOnRack")]
		private static void PositionSuitsOnRackPostfix()
		{
			RunPatch("StartOfRound.PositionSuitsOnRack", delegate
			{
				DrawableSuitsPlugin.Registry?.ReapplyAllIfReady("StartOfRound.PositionSuitsOnRack");
			});
		}

		[HarmonyPostfix]
		[HarmonyPatch("SyncSuitsClientRpc")]
		private static void SyncSuitsClientRpcPostfix()
		{
			RunPatch("StartOfRound.SyncSuitsClientRpc", delegate
			{
				DrawableSuitsPlugin.Registry?.ReapplyAllIfReady("StartOfRound.SyncSuitsClientRpc");
			});
		}

		[HarmonyPostfix]
		[HarmonyPatch("OnPlayerConnectedClientRpc")]
		private static void OnPlayerConnectedClientRpcPostfix()
		{
			RunPatch("StartOfRound.OnPlayerConnectedClientRpc", delegate
			{
				DrawableSuitsPlugin.Registry?.ReapplyAllIfReady("StartOfRound.OnPlayerConnectedClientRpc");
				SessionSafetyGuard.Run("StartOfRound.OnPlayerConnectedClientRpc", forceLog: true);
				DrawableSuitsPlugin.Sync?.RequestActiveDesigns();
			});
		}

		private static void RunPatch(string context, Action action)
		{
			try
			{
				DrawableSuitsPlugin.EnsureRuntimeReady(context);
				action();
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception("Patch failed: " + context, exception);
			}
		}
	}
	[HarmonyPatch(typeof(UnlockableSuit))]
	internal static class UnlockableSuitPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("SwitchSuitForPlayer")]
		private static void SwitchSuitForPlayerPostfix(PlayerControllerB player)
		{
			RunPatch("UnlockableSuit.SwitchSuitForPlayer", delegate
			{
				DrawableSuitsPlugin.Registry?.RecordPlayerSuitSnapshot(player, "UnlockableSuit.SwitchSuitForPlayer");
				DrawableSuitsPlugin.Registry?.ApplyToPlayer(player);
				DrawableSuitsPlugin.Registry?.ScheduleReapplyAll("UnlockableSuit.SwitchSuitForPlayer");
			});
		}

		[HarmonyPostfix]
		[HarmonyPatch("SwitchSuitForAllPlayers")]
		private static void SwitchSuitForAllPlayersPostfix()
		{
			RunPatch("UnlockableSuit.SwitchSuitForAllPlayers", delegate
			{
				DrawableSuitsPlugin.Registry?.ReapplyAllIfReady("UnlockableSuit.SwitchSuitForAllPlayers");
			});
		}

		private static void RunPatch(string context, Action action)
		{
			try
			{
				DrawableSuitsPlugin.EnsureRuntimeReady(context);
				action();
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception("Patch failed: " + context, exception);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal static class PlayerControllerBPatches
	{
		private static readonly string[] OptionalBlockedInputMethods = new string[25]
		{
			"ScrollMouse_performed", "ScrollMouse_canceled", "SwitchItem_performed", "SwitchItem_canceled", "NextItem_performed", "PreviousItem_performed", "Scan_performed", "PingScan_performed", "ItemPrimaryUse_performed", "ItemInteract_performed",
			"ItemSecondaryUse_performed", "ItemTertiaryUse_performed", "ActivateItem_performed", "ActivateItem_canceled", "Discard_performed", "Crouch_performed", "InspectItem_performed", "UseUtilitySlot_performed", "Emote1_performed", "Emote2_performed",
			"SetFreeCamera_performed", "SpeedCheat_performed", "BuildMode_performed", "ConfirmBuildMode_performed", "Delete_performed"
		};

		private static readonly HashSet<string> OptionalPatchedMethods = new HashSet<string>(StringComparer.Ordinal);

		private static float _lastBlockedInputLogTime;

		private static string _lastBlockedInputMethod;

		internal static void ApplyOptionalGameplayInputPatches(Harmony harmony)
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			if (harmony == null)
			{
				return;
			}
			MethodInfo methodInfo = AccessTools.Method(typeof(PlayerControllerBPatches), "OptionalGameplayInputPrefix", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				DrawableSuitsDiagnostics.Warn("Optional gameplay input prefix was not found; scan/inventory fallback patches were not applied.");
				return;
			}
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			for (int i = 0; i < OptionalBlockedInputMethods.Length; i++)
			{
				string text = OptionalBlockedInputMethods[i];
				if (OptionalPatchedMethods.Contains(text))
				{
					continue;
				}
				MethodInfo methodInfo2 = null;
				try
				{
					methodInfo2 = AccessTools.Method(typeof(PlayerControllerB), text, (Type[])null, (Type[])null);
				}
				catch (Exception exception)
				{
					DrawableSuitsDiagnostics.Exception("Optional PlayerControllerB input method lookup failed for " + text, exception);
					list2.Add(text);
					continue;
				}
				if (methodInfo2 == null)
				{
					list2.Add(text);
					continue;
				}
				try
				{
					harmony.Patch((MethodBase)methodInfo2, new HarmonyMethod(methodInfo), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					OptionalPatchedMethods.Add(text);
					list.Add(text);
				}
				catch (Exception exception2)
				{
					DrawableSuitsDiagnostics.Exception("Failed to apply optional PlayerControllerB input block for " + text, exception2);
				}
			}
			DrawableSuitsDiagnostics.Info("Optional gameplay input patches applied. patched=[" + string.Join(", ", list) + "]; missing=[" + string.Join(", ", list2) + "]");
		}

		[HarmonyPostfix]
		[HarmonyPatch("ConnectClientToPlayerObject")]
		private static void ConnectClientToPlayerObjectPostfix(PlayerControllerB __instance)
		{
			RunPatch("PlayerControllerB.ConnectClientToPlayerObject", delegate
			{
				DrawableSuitsPlugin.Registry?.RecordPlayerSuitSnapshot(__instance, "PlayerControllerB.ConnectClientToPlayerObject");
				DrawableSuitsPlugin.Registry?.ApplyToPlayer(__instance);
				DrawableSuitsPlugin.Registry?.ScheduleReapplyAll("PlayerControllerB.ConnectClientToPlayerObject");
				SessionSafetyGuard.Run("PlayerControllerB.ConnectClientToPlayerObject", forceLog: true);
				DrawableSuitsPlugin.Sync?.RequestActiveDesigns();
			});
		}

		[HarmonyPostfix]
		[HarmonyPatch("SpawnPlayerAnimation")]
		private static void SpawnPlayerAnimationPostfix(PlayerControllerB __instance)
		{
			RunPatch("PlayerControllerB.SpawnPlayerAnimation", delegate
			{
				DrawableSuitsPlugin.Registry?.RecordPlayerSuitSnapshot(__instance, "PlayerControllerB.SpawnPlayerAnimation");
				DrawableSuitsPlugin.Registry?.ApplyToPlayer(__instance);
				DrawableSuitsPlugin.Registry?.ScheduleReapplyAll("PlayerControllerB.SpawnPlayerAnimation");
				SessionSafetyGuard.Run("PlayerControllerB.SpawnPlayerAnimation", forceLog: true);
			});
		}

		[HarmonyPostfix]
		[HarmonyPatch("SpawnDeadBody", new Type[]
		{
			typeof(int),
			typeof(Vector3),
			typeof(int),
			typeof(PlayerControllerB),
			typeof(int),
			typeof(Transform),
			typeof(Transform),
			typeof(Vector3)
		})]
		private static void SpawnDeadBodyPostfix(int playerId, PlayerControllerB deadPlayerController)
		{
			RunPatch("PlayerControllerB.SpawnDeadBody", delegate
			{
				DrawableSuitsPlugin.Registry?.RecordPlayerSuitSnapshot(deadPlayerController, "PlayerControllerB.SpawnDeadBody");
				DeadBodyInfo val = deadPlayerController?.deadBody;
				if ((Object)(object)val != (Object)null)
				{
					DrawableSuitsPlugin.Registry?.ApplyToDeadBody(val, "PlayerControllerB.SpawnDeadBody:deadPlayerController.deadBody");
					DrawableSuitsPlugin.Registry?.ScheduleDeadBodyReapply(val, "PlayerControllerB.SpawnDeadBody:deadPlayerController.deadBody");
					DrawableSuitsDiagnostics.Info($"DeadBodySuitSpawnPatch: playerId={playerId}; exactBody={((Object)val).name}; deadPlayer={DrawableSuitsPlugin.DescribeUnityObject((Object)(object)deadPlayerController)}");
				}
				else
				{
					DeadBodyInfo[] array = Object.FindObjectsOfType<DeadBodyInfo>();
					int num = 0;
					if (array != null)
					{
						foreach (DeadBodyInfo val2 in array)
						{
							if (!((Object)(object)val2 == (Object)null) && val2.playerObjectId == playerId)
							{
								DrawableSuitsPlugin.Registry?.ApplyToDeadBody(val2, "PlayerControllerB.SpawnDeadBody");
								DrawableSuitsPlugin.Registry?.ScheduleDeadBodyReapply(val2, "PlayerControllerB.SpawnDeadBody");
								num++;
							}
						}
					}
					DrawableSuitsDiagnostics.Info($"DeadBodySuitSpawnPatch: playerId={playerId}; matchedBodies={num}; deadPlayer={DrawableSuitsPlugin.DescribeUnityObject((Object)(object)deadPlayerController)}");
				}
			});
		}

		[HarmonyPrefix]
		[HarmonyPatch("Jump_performed")]
		private static bool JumpPerformedPrefix(PlayerControllerB __instance)
		{
			return AllowGameplayInput("Jump_performed", __instance);
		}

		[HarmonyPrefix]
		[HarmonyPatch("Interact_performed")]
		private static bool InteractPerformedPrefix(PlayerControllerB __instance)
		{
			return AllowGameplayInput("Interact_performed", __instance);
		}

		[HarmonyPrefix]
		[HarmonyPatch("QEItemInteract_performed")]
		private static bool QeItemInteractPerformedPrefix(PlayerControllerB __instance)
		{
			return AllowGameplayInput("QEItemInteract_performed", __instance);
		}

		[HarmonyPrefix]
		[HarmonyPatch("Look_performed")]
		private static bool LookPerformedPrefix(PlayerControllerB __instance)
		{
			return AllowGameplayInput("Look_performed", __instance);
		}

		private static bool OptionalGameplayInputPrefix(PlayerControllerB __instance, MethodBase __originalMethod)
		{
			return AllowGameplayInput(__originalMethod?.Name ?? "OptionalGameplayInput", __instance);
		}

		private static void RunPatch(string context, Action action)
		{
			try
			{
				DrawableSuitsPlugin.EnsureRuntimeReady(context);
				action();
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception("Patch failed: " + context, exception);
			}
		}

		private static bool AllowGameplayInput(string method, PlayerControllerB player)
		{
			if (!DrawableSuitsPlugin.IsEditorOpen)
			{
				return true;
			}
			if (Time.unscaledTime - _lastBlockedInputLogTime > 0.75f || !string.Equals(_lastBlockedInputMethod, method, StringComparison.Ordinal))
			{
				_lastBlockedInputLogTime = Time.unscaledTime;
				_lastBlockedInputMethod = method;
				DrawableSuitsDiagnostics.Info("Blocked PlayerControllerB." + method + " while DrawableSuits editor is open. player=" + DrawableSuitsPlugin.DescribeUnityObject((Object)(object)player));
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(DeadBodyInfo))]
	internal static class DeadBodyInfoPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("ChangeMesh")]
		private static void ChangeMeshPrefix(DeadBodyInfo __instance, ref Material changeMaterial)
		{
			try
			{
				DrawableSuitsPlugin.EnsureRuntimeReady("DeadBodyInfo.ChangeMesh.prefix");
				if ((Object)(object)DrawableSuitsPlugin.Registry != (Object)null && DrawableSuitsPlugin.Registry.TryGetDeadBodyRuntimeMaterial(__instance, "DeadBodyInfo.ChangeMesh.prefix", out var material, out var reason))
				{
					string text = (((Object)(object)changeMaterial != (Object)null) ? ((Object)changeMaterial).name : "null");
					changeMaterial = material;
					DrawableSuitsDiagnostics.Info("DeadBodySuitMaterialSubstituted: context=DeadBodyInfo.ChangeMesh.prefix; previousMaterial=" + text + "; newMaterial=" + ((Object)material).name + "; reason=" + reason + "; body=" + DrawableSuitsPlugin.DescribeUnityObject((Object)(object)__instance));
				}
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception("Patch failed: DeadBodyInfo.ChangeMesh.prefix", exception);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void StartPostfix(DeadBodyInfo __instance)
		{
			RunPatch("DeadBodyInfo.Start", __instance);
		}

		[HarmonyPostfix]
		[HarmonyPatch("ChangeMesh")]
		private static void ChangeMeshPostfix(DeadBodyInfo __instance)
		{
			RunPatch("DeadBodyInfo.ChangeMesh", __instance);
		}

		private static void RunPatch(string context, DeadBodyInfo body)
		{
			try
			{
				DrawableSuitsPlugin.EnsureRuntimeReady(context);
				DrawableSuitsPlugin.Registry?.ApplyToDeadBody(body, context);
				DrawableSuitsPlugin.Registry?.ScheduleDeadBodyReapply(body, context);
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception("Patch failed: " + context, exception);
			}
		}
	}
	[HarmonyPatch(typeof(QuickMenuManager))]
	internal static class QuickMenuManagerPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void StartPostfix(QuickMenuManager __instance)
		{
			RunPatch("QuickMenuManager.Start", delegate
			{
				PauseMenuButtonInjector.EnsureButton(__instance);
			});
		}

		[HarmonyPostfix]
		[HarmonyPatch("OpenQuickMenu")]
		private static void OpenQuickMenuPostfix(QuickMenuManager __instance)
		{
			RunPatch("QuickMenuManager.OpenQuickMenu", delegate
			{
				PauseMenuButtonInjector.EnsureButton(__instance);
				PauseMenuButtonInjector.SelectIfNeeded(__instance);
			});
		}

		private static void RunPatch(string context, Action action)
		{
			try
			{
				DrawableSuitsPlugin.EnsureRuntimeReady(context);
				action();
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception("Patch failed: " + context, exception);
			}
		}
	}
	internal static class PauseMenuButtonInjector
	{
		private sealed class MenuRow
		{
			public GameObject GameObject { get; }

			public RectTransform RectTransform { get; }

			public Button Button { get; }

			public string LabelText { get; }

			public bool IsDrawable
			{
				get
				{
					if (!(((Object)GameObject).name == "DrawableSuitsButton"))
					{
						return Normalize(LabelText).Contains("drawablesuits");
					}
					return true;
				}
			}

			public MenuRow(GameObject gameObject, RectTransform rectTransform, Button button, string labelText)
			{
				GameObject = gameObject;
				RectTransform = rectTransform;
				Button = button;
				LabelText = labelText ?? string.Empty;
			}
		}

		private const string ButtonName = "DrawableSuitsButton";

		private const string ButtonText = "DrawableSuits";

		private const string ButtonTextWithInlinePrefix = "> DrawableSuits";

		private const string PrefixText = ">";

		private const float MinimumRowSpacing = 36f;

		private const float FallbackRowSpacing = 92f;

		public static void EnsureButton(QuickMenuManager quickMenu)
		{
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)quickMenu == (Object)null || (Object)(object)quickMenu.mainButtonsPanel == (Object)null)
			{
				DrawableSuitsDiagnostics.Warn($"EnsureButton skipped. quickMenuNull={(Object)(object)quickMenu == (Object)null}; mainButtonsPanelNull={(Object)(object)quickMenu?.mainButtonsPanel == (Object)null}");
				return;
			}
			RectTransform component = quickMenu.mainButtonsPanel.GetComponent<RectTransform>();
			if ((Object)(object)component == (Object)null)
			{
				DrawableSuitsDiagnostics.Warn("EnsureButton skipped because QuickMenuManager.mainButtonsPanel has no RectTransform.");
				return;
			}
			List<MenuRow> list = CollectRows((Transform)(object)component);
			DrawableSuitsDiagnostics.Info($"EnsureButton started. menuOpen={quickMenu.isMenuOpen}; panel={((Object)component).name}; rowsFound={list.Count}; labels=[{DescribeRows(list)}]");
			MenuRow menuRow = ChooseTemplateRow(list);
			DrawableSuitsDiagnostics.Info("Pause-menu DrawableSuits template selected: label=" + (menuRow?.LabelText ?? "none") + "; object=" + (((menuRow != null) ? ((Object)menuRow.GameObject).name : null) ?? "none") + "; sibling=" + (((menuRow != null) ? ((Transform)menuRow.RectTransform).GetSiblingIndex().ToString() : null) ?? "none"));
			GameObject val = FindExistingButton((Transform)(object)component);
			if ((Object)(object)val != (Object)null && menuRow != null)
			{
				DrawableSuitsDiagnostics.Info("Replacing existing DrawableSuits pause button with a fresh clone so native prefix/arrow children match the current menu template.");
				val.SetActive(false);
				Object.Destroy((Object)(object)val);
				val = null;
			}
			if ((Object)(object)val == (Object)null)
			{
				DrawableSuitsDiagnostics.Info("No existing DrawableSuits pause button. template=" + ((menuRow != null) ? (menuRow.LabelText + "/" + ((Object)menuRow.GameObject).name) : "none") + ".");
				val = ((menuRow != null) ? CloneTemplate(menuRow) : CreateFallbackButton((Transform)(object)component));
			}
			else
			{
				DrawableSuitsDiagnostics.Info($"Reusing existing DrawableSuits pause button. active={val.activeSelf}; siblingIndex={val.transform.GetSiblingIndex()}");
			}
			if ((Object)(object)val == (Object)null)
			{
				DrawableSuitsDiagnostics.Warn("Could not create pause-menu DrawableSuits button.");
				return;
			}
			RemoveDuplicateButtons((Transform)(object)component, val);
			ConfigureButton(val, quickMenu, menuRow);
			PlaceButtonAndRows(component, val);
			RebuildNavigation(component);
			RectTransform component2 = val.GetComponent<RectTransform>();
			Button component3 = val.GetComponent<Button>();
			DrawableSuitsDiagnostics.Info(string.Format("EnsureButton complete. exists={0}; active={1}; anchoredPosition={2}; siblingIndex={3}; nav={4}; colors={5}; rowsAfter={6}", (Object)(object)val != (Object)null, val.activeSelf, ((component2 != null) ? ((object)component2.anchoredPosition/*cast due to .constrained prefix*/).ToString() : null) ?? "null", val.transform.GetSiblingIndex(), DescribeNavigation(component3), DescribeButtonColors(component3), CollectRows((Transform)(object)component).Count));
		}

		public static void SelectIfNeeded(QuickMenuManager quickMenu)
		{
			if (!((Object)(object)quickMenu == (Object)null) && quickMenu.isMenuOpen && !((Object)(object)quickMenu.mainButtonsPanel == (Object)null) && !((Object)(object)EventSystem.current == (Object)null) && !((Object)(object)EventSystem.current.currentSelectedGameObject != (Object)null))
			{
				List<MenuRow> rowsInVisualOrder = GetRowsInVisualOrder(quickMenu.mainButtonsPanel.GetComponent<RectTransform>());
				if (rowsInVisualOrder.Count > 0)
				{
					EventSystem.current.SetSelectedGameObject(rowsInVisualOrder[0].GameObject);
				}
			}
		}

		private static GameObject FindExistingButton(Transform panel)
		{
			Button[] componentsInChildren = ((Component)panel).GetComponentsInChildren<Button>(true);
			foreach (Button val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && ((Object)((Component)val).gameObject).name == "DrawableSuitsButton")
				{
					return ((Component)val).gameObject;
				}
			}
			return null;
		}

		private static void RemoveDuplicateButtons(Transform panel, GameObject keep)
		{
			Button[] componentsInChildren = ((Component)panel).GetComponentsInChildren<Button>(true);
			foreach (Button val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)(object)keep) && !(((Object)((Component)val).gameObject).name != "DrawableSuitsButton"))
				{
					((Component)val).gameObject.SetActive(false);
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
		}

		private static GameObject CloneTemplate(MenuRow template)
		{
			//IL_0065: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Object.Instantiate<GameObject>(template.GameObject, ((Transform)template.RectTransform).parent, false);
			((Object)obj).name = "DrawableSuitsButton";
			obj.transform.SetAsLastSibling();
			obj.SetActive(true);
			DrawableSuitsDiagnostics.Info("Cloned pause-menu template '" + template.LabelText + "' into DrawableSuitsButton.");
			RectTransform component = obj.GetComponent<RectTransform>();
			if ((Object)(object)component != (Object)null)
			{
				component.anchorMin = template.RectTransform.anchorMin;
				component.anchorMax = template.RectTransform.anchorMax;
				component.pivot = template.RectTransform.pivot;
				component.sizeDelta = template.RectTransform.sizeDelta;
				((Transform)component).localScale = ((Transform)template.RectTransform).localScale;
			}
			return obj;
		}

		private static GameObject CreateFallbackButton(Transform panel)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("DrawableSuitsButton", new Type[5]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image),
				typeof(Button),
				typeof(LayoutElement)
			});
			val.transform.SetParent(panel, false);
			val.transform.SetAsLastSibling();
			DrawableSuitsDiagnostics.Warn("Created fallback pause-menu DrawableSuits button because no cloneable row template was found.");
			val.GetComponent<RectTransform>().sizeDelta = new Vector2(260f, 54f);
			((Graphic)val.GetComponent<Image>()).color = new Color(0.08f, 0.08f, 0.08f, 0.86f);
			LayoutElement component = val.GetComponent<LayoutElement>();
			component.preferredWidth = 260f;
			component.preferredHeight = 54f;
			component.minHeight = 42f;
			GameObject val2 = new GameObject("Label", new Type[2]
			{
				typeof(RectTransform),
				typeof(TextMeshProUGUI)
			});
			val2.transform.SetParent(val.transform, false);
			RectTransform component2 = val2.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.offsetMin = new Vector2(8f, 2f);
			component2.offsetMax = new Vector2(-8f, -2f);
			TextMeshProUGUI component3 = val2.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component3).alignment = (TextAlignmentOptions)514;
			((TMP_Text)component3).fontSize = 24f;
			((Graphic)component3).color = Color.white;
			TextMeshProUGUI componentInChildren = ((Component)panel).GetComponentInChildren<TextMeshProUGUI>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				((TMP_Text)component3).font = ((TMP_Text)componentInChildren).font;
				((TMP_Text)component3).fontSharedMaterial = ((TMP_Text)componentInChildren).fontSharedMaterial;
				((TMP_Text)component3).fontSize = ((TMP_Text)componentInChildren).fontSize;
				((Graphic)component3).color = ((Graphic)componentInChildren).color;
			}
			return val;
		}

		private static void ConfigureButton(GameObject buttonObject, QuickMenuManager quickMenu, MenuRow template)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			//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_00bd: Unknown result type (might be due to invalid IL or missing references)
			((Object)buttonObject).name = "DrawableSuitsButton";
			buttonObject.SetActive(true);
			if (template != null)
			{
				ApplyTemplateStyle(template, buttonObject);
			}
			SetButtonText(buttonObject, template?.LabelText);
			EnsureNativePrefix(buttonObject, template);
			Button val = buttonObject.GetComponent<Button>() ?? buttonObject.AddComponent<Button>();
			((Selectable)val).interactable = true;
			val.onClick = new ButtonClickedEvent();
			((UnityEvent)val.onClick).AddListener((UnityAction)delegate
			{
				OpenEditorFromPauseMenu(quickMenu);
			});
			DrawableSuitsDiagnostics.Info($"Configured pause-menu button listener. button={((Object)buttonObject).name}; interactable={((Selectable)val).interactable}; targetQuickMenuNull={(Object)(object)quickMenu == (Object)null}");
			Navigation navigation = ((Selectable)val).navigation;
			((Navigation)(ref navigation)).mode = (Mode)3;
			((Selectable)val).navigation = navigation;
		}

		private static void ApplyTemplateStyle(MenuRow template, GameObject buttonObject)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: 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_0140: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = buttonObject.GetComponent<RectTransform>();
			if ((Object)(object)component != (Object)null)
			{
				CopyRectTemplate(template.RectTransform, component);
			}
			Button button = template.Button;
			Button val = buttonObject.GetComponent<Button>() ?? buttonObject.AddComponent<Button>();
			((Selectable)val).transition = ((Selectable)button).transition;
			((Selectable)val).colors = ((Selectable)button).colors;
			((Selectable)val).spriteState = ((Selectable)button).spriteState;
			((Selectable)val).animationTriggers = ((Selectable)button).animationTriggers;
			((Selectable)val).targetGraphic = FindMatchingGraphic(((Selectable)button).targetGraphic, template.GameObject.transform, buttonObject.transform) ?? buttonObject.GetComponent<Graphic>() ?? buttonObject.GetComponentInChildren<Graphic>(true);
			Image component2 = template.GameObject.GetComponent<Image>();
			Image component3 = buttonObject.GetComponent<Image>();
			if ((Object)(object)component2 != (Object)null && (Object)(object)component3 != (Object)null)
			{
				component3.sprite = component2.sprite;
				component3.overrideSprite = component2.overrideSprite;
				component3.type = component2.type;
				component3.preserveAspect = component2.preserveAspect;
				component3.fillCenter = component2.fillCenter;
				component3.fillMethod = component2.fillMethod;
				component3.fillAmount = component2.fillAmount;
				component3.fillClockwise = component2.fillClockwise;
				component3.fillOrigin = component2.fillOrigin;
				((Graphic)component3).color = ((Graphic)component2).color;
				((Graphic)component3).material = ((Graphic)component2).material;
				((Graphic)component3).raycastTarget = ((Graphic)component2).raycastTarget;
			}
			LayoutElement component4 = template.GameObject.GetComponent<LayoutElement>();
			LayoutElement val2 = buttonObject.GetComponent<LayoutElement>();
			if ((Object)(object)component4 != (Object)null)
			{
				if (val2 == null)
				{
					val2 = buttonObject.AddComponent<LayoutElement>();
				}
				val2.ignoreLayout = component4.ignoreLayout;
				val2.minWidth = component4.minWidth;
				val2.minHeight = component4.minHeight;
				val2.preferredWidth = component4.preferredWidth;
				val2.preferredHeight = component4.preferredHeight;
				val2.flexibleWidth = component4.flexibleWidth;
				val2.flexibleHeight = component4.flexibleHeight;
				val2.layoutPriority = component4.layoutPriority;
			}
			DrawableSuitsDiagnostics.Info("Applied pause-menu template style. template=" + template.LabelText + "/" + ((Object)template.GameObject).name + "; target=" + ((Object)buttonObject).name + "; colors=" + DescribeButtonColors(val));
		}

		private static void SetButtonText(GameObject buttonObject, string templateLabelText)
		{
			TextMeshProUGUI[] componentsInChildren = buttonObject.GetComponentsInChildren<TextMeshProUGUI>(true);
			TextMeshProUGUI val = FindPrimaryTmpLabel(componentsInChildren, templateLabelText);
			List<string> list = new List<string>();
			TextMeshProUGUI[] array = componentsInChildren;
			foreach (TextMeshProUGUI val2 in array)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					if ((Object)(object)val2 == (Object)(object)val)
					{
						((TMP_Text)val2).text = "DrawableSuits";
						((TMP_Text)val2).enableWordWrapping = false;
					}
					else
					{
						list.Add(((TMP_Text)val2).text ?? string.Empty);
					}
				}
			}
			Text[] componentsInChildren2 = buttonObject.GetComponentsInChildren<Text>(true);
			Text val3 = (((Object)(object)val == (Object)null) ? FindPrimaryLegacyLabel(componentsInChildren2, templateLabelText) : null);
			Text[] array2 = componentsInChildren2;
			foreach (Text val4 in array2)
			{
				if (!((Object)(object)val4 == (Object)null))
				{
					if ((Object)(object)val4 == (Object)(object)val3)
					{
						val4.text = "DrawableSuits";
					}
					else
					{
						list.Add(val4.text ?? string.Empty);
					}
				}
			}
			DrawableSuitsDiagnostics.Info("Pause-menu DrawableSuits text configured. templateLabel=" + (templateLabelText ?? "none") + "; primaryTmp=" + DescribeTmpLabel(val) + "; primaryLegacy=" + DescribeLegacyLabel(val3) + "; preserved=[" + string.Join(", ", list) + "]");
		}

		private static void EnsureNativePrefix(GameObject buttonObject, MenuRow template)
		{
			TextMeshProUGUI val = FindPrefixText(buttonObject);
			if ((Object)(object)val != (Object)null)
			{
				TextMeshProUGUI label = FindPrimaryTmpLabel(buttonObject.GetComponentsInChildren<TextMeshProUGUI>(true), "DrawableSuits");
				DrawableSuitsDiagnostics.Info($"PauseMenuPrefixMode mode=PreservedChild; prefix={((Object)((Component)val).gameObject).name}; prefixText='{((TMP_Text)val).text}'; primary={DescribeTmpLabel(label)}; rowRect={DescribeRect(buttonObject.GetComponent<RectTransform>())}; sibling={buttonObject.transform.GetSiblingIndex()}");
				return;
			}
			Text val2 = FindPrefixLegacyText(buttonObject);
			if ((Object)(object)val2 != (Object)null)
			{
				Text label2 = FindPrimaryLegacyLabel(buttonObject.GetComponentsInChildren<Text>(true), "DrawableSuits");
				DrawableSuitsDiagnostics.Info($"PauseMenuPrefixMode mode=PreservedChild; prefix={((Object)((Component)val2).gameObject).name}; prefixText='{val2.text}'; primary={DescribeLegacyLabel(label2)}; rowRect={DescribeRect(buttonObject.GetComponent<RectTransform>())}; sibling={buttonObject.transform.GetSiblingIndex()}");
				return;
			}
			TextMeshProUGUI val3 = FindPrimaryTmpLabel(buttonObject.GetComponentsInChildren<TextMeshProUGUI>(true), "DrawableSuits");
			if ((Object)(object)val3 != (Object)null)
			{
				((TMP_Text)val3).text = "> DrawableSuits";
				((TMP_Text)val3).enableWordWrapping = false;
				DrawableSuitsDiagnostics.Info($"PauseMenuPrefixMode mode=InlineLabel; displayed='{((TMP_Text)val3).text}'; primary={DescribeTmpLabel(val3)}; rowRect={DescribeRect(buttonObject.GetComponent<RectTransform>())}; sibling={buttonObject.transform.GetSiblingIndex()}");
				return;
			}
			Text val4 = FindPrimaryLegacyLabel(buttonObject.GetComponentsInChildren<Text>(true), "DrawableSuits");
			if ((Object)(object)val4 != (Object)null)
			{
				val4.text = "> DrawableSuits";
				DrawableSuitsDiagnostics.Info($"PauseMenuPrefixMode mode=InlineLabel; displayed='{val4.text}'; primary={DescribeLegacyLabel(val4)}; rowRect={DescribeRect(buttonObject.GetComponent<RectTransform>())}; sibling={buttonObject.transform.GetSiblingIndex()}");
			}
			else
			{
				DrawableSuitsDiagnostics.Warn(string.Format("PauseMenuPrefixMode mode=SkippedNoPrimaryLabel; template={0}; button={1}; rowRect={2}; sibling={3}", template?.LabelText ?? "none", ((Object)buttonObject).name, DescribeRect(buttonObject.GetComponent<RectTransform>()), buttonObject.transform.GetSiblingIndex()));
			}
		}

		private static TextMeshProUGUI FindPrefixText(GameObject buttonObject)
		{
			TextMeshProUGUI[] componentsInChildren = buttonObject.GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && Normalize(((TMP_Text)val).text) == ">")
				{
					return val;
				}
			}
			return null;
		}

		private static Text FindPrefixLegacyText(GameObject buttonObject)
		{
			Text[] componentsInChildren = buttonObject.GetComponentsInChildren<Text>(true);
			foreach (Text val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && Normalize(val.text) == ">")
				{
					return val;
				}
			}
			return null;
		}

		private static void PlaceButtonAndRows(RectTransform panel, GameObject buttonObject)
		{
			List<MenuRow> rows = CollectRows((Transform)(object)panel);
			MenuRow menuRow = FindRowFor(buttonObject, rows);
			if (menuRow == null)
			{
				DrawableSuitsDiagnostics.Warn("PlaceButtonAndRows could not find the DrawableSuits row after collection.");
				return;
			}
			LayoutGroup component = ((Component)panel).GetComponent<LayoutGroup>();
			if ((Object)(object)component != (Object)null && ((Behaviour)component).enabled)
			{
				DrawableSuitsDiagnostics.Info("PlaceButtonAndRows using layout group " + ((object)component).GetType().Name + ".");
				InsertAfterResumeBySibling(rows, menuRow);
				LayoutRebuilder.ForceRebuildLayoutImmediate(panel);
			}
			else
			{
				DrawableSuitsDiagnostics.Info("PlaceButtonAndRows using explicit anchored positions.");
				PlaceRowsExplicitly(rows, menuRow);
			}
		}

		private static void InsertAfterResumeBySibling(List<MenuRow> rows, MenuRow drawable)
		{
			MenuRow menuRow = FindResumeRow(rows) ?? FirstNonDrawableRow(rows);
			if (menuRow == null)
			{
				((Transform)drawable.RectTransform).SetAsLastSibling();
			}
			else
			{
				((Transform)drawable.RectTransform).SetSiblingIndex(((Transform)menuRow.RectTransform).GetSiblingIndex() + 1);
			}
		}

		private static void PlaceRowsExplicitly(List<MenuRow> rows, MenuRow drawable)
		{
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			List<MenuRow> list = new List<MenuRow>();
			foreach (MenuRow row in rows)
			{
				if ((Object)(object)((Transform)row.RectTransform).parent == (Object)(object)((Transform)drawable.RectTransform).parent)
				{
					list.Add(row);
				}
			}
			if (list.Count == 0)
			{
				DrawableSuitsDiagnostics.Warn("PlaceRowsExplicitly found no same-parent rows.");
				return;
			}
			MenuRow menuRow = FindResumeRow(list) ?? FirstNonDrawableRow(list);
			if (menuRow == null)
			{
				DrawableSuitsDiagnostics.Warn("PlaceRowsExplicitly found no resume or non-Drawable row.");
				return;
			}
			CopyRectTemplate(menuRow.RectTransform, drawable.RectTransform);
			list.Sort(CompareTopToBottom);
			List<MenuRow> list2 = new List<MenuRow>();
			foreach (MenuRow item in list)
			{
				if (!item.IsDrawable)
				{
					list2.Add(item);
				}
			}
			int num = list2.IndexOf(menuRow);
			if (num < 0)
			{
				num = 0;
			}
			float num2 = DetectRowSpacing(list2);
			MenuRow menuRow2 = ((num + 1 < list2.Count) ? list2[num + 1] : null);
			float num3 = ((menuRow2 != null) ? Mathf.Abs(menuRow.RectTransform.anchoredPosition.y - menuRow2.RectTransform.anchoredPosition.y) : float.PositiveInfinity);
			bool num4 = menuRow2 != null && num3 < num2 * 1.45f;
			float y = menuRow.RectTransform.anchoredPosition.y - num2;
			int num5 = ((Transform)menuRow.RectTransform).GetSiblingIndex() + 1;
			Vector2 anchoredPosition = menuRow.RectTransform.anchoredPosition;
			anchoredPosition.y = y;
			drawable.RectTransform.anchoredPosition = anchoredPosition;
			((Transform)drawable.RectTransform).SetSiblingIndex(num5);
			int num6 = 0;
			if (num4)
			{
				for (int i = num + 1; i < list2.Count; i++)
				{
					MenuRow menuRow3 = list2[i];
					Vector2 anchoredPosition2 = menuRow3.RectTransform.anchoredPosition;
					anchoredPosition2.y -= num2;
					menuRow3.RectTransform.anchoredPosition = anchoredPosition2;
					((Transform)menuRow3.RectTransform).SetSiblingIndex(num5 + 1 + (i - num - 1));
					num6++;
				}
			}
			DrawableSuitsDiagnostics.Info(string.Format("PlaceRowsExplicitly nativeCount={0}; resume={1}; next={2}; spacing={3}; gapToNext={4}; shiftedLowerRows={5}; drawablePosition={6}; drawableSibling={7}", list2.Count, menuRow.LabelText, menuRow2?.LabelText ?? "none", num2, num3, num6, drawable.RectTransform.anchoredPosition, ((Transform)drawable.RectTransform).GetSiblingIndex()));
		}

		private static void CopyRectTemplate(RectTransform source, RectTransform target)
		{
			//IL_0002: 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_0026: 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)
			target.anchorMin = source.anchorMin;
			target.anchorMax = source.anchorMax;
			target.pivot = source.pivot;
			target.sizeDelta = source.sizeDelta;
			((Transform)target).localScale = ((Transform)source).localScale;
		}

		private static float DetectRowSpacing(List<MenuRow> rows)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			List<float> list = new List<float>();
			foreach (MenuRow row in rows)
			{
				list.Add(row.RectTransform.anchoredPosition.y);
			}
			list.Sort((float a, float b) => b.CompareTo(a));
			List<float> list2 = new List<float>();
			for (int num = 0; num < list.Count - 1; num++)
			{
				float num2 = Mathf.Abs(list[num] - list[num + 1]);
				if (num2 >= 36f && num2 <= 240f)
				{
					list2.Add(num2);
				}
			}
			if (list2.Count > 0)
			{
				list2.Sort();
				return Mathf.Max(36f, list2[list2.Count / 2]);
			}
			float num3 = 0f;
			foreach (MenuRow row2 in rows)
			{
				float[] obj = new float[3] { num3, 0f, 0f };
				Rect rect = row2.RectTransform.rect;
				obj[1] = ((Rect)(ref rect)).height;
				obj[2] = row2.RectTransform.sizeDelta.y;
				num3 = Mathf.Max(obj);
			}
			return Mathf.Max(92f, num3 + 24f);
		}

		private static Graphic FindMatchingGraphic(Graphic templateGraphic, Transform templateRoot, Transform targetRoot)
		{
			if ((Object)(object)templateGraphic == (Object)null || (Object)(object)templateRoot == (Object)null || (Object)(object)targetRoot == (Object)null)
			{
				return null;
			}
			string relativePath = GetRelativePath(templateRoot, ((Component)templateGraphic).transform);
			Transform val = (string.IsNullOrEmpty(relativePath) ? targetRoot : targetRoot.Find(relativePath));
			Graphic val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<Graphic>() : null);
			DrawableSuitsDiagnostics.Info("Pause-menu targetGraphic mapping. templateGraphic=" + ((Object)templateGraphic).name + "; path=" + relativePath + "; mapped=" + (((val2 != null) ? ((Object)val2).name : null) ?? "none"));
			return val2;
		}

		private static string GetRelativePath(Transform root, Transform child)
		{
			if ((Object)(object)root == (Object)null || (Object)(object)child == (Object)null || (Object)(object)child == (Object)(object)root)
			{
				return string.Empty;
			}
			List<string> list = new List<string>();
			Transform val = child;
			while ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)root)
			{
				list.Insert(0, ((Object)val).name);
				val = val.parent;
			}
			if (!((Object)(object)val == (Object)(object)root))
			{
				return string.Empty;
			}
			return string.Join("/", list);
		}

		private static void RebuildNavigation(RectTransform panel)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			List<MenuRow> rowsInVisualOrder = GetRowsInVisualOrder(panel);
			if (rowsInVisualOrder.Count == 0)
			{
				DrawableSuitsDiagnostics.Warn("RebuildNavigation skipped because no rows were collected.");
				return;
			}
			for (int i = 0; i < rowsInVisualOrder.Count; i++)
			{
				Button button = rowsInVisualOrder[i].Button;
				Navigation navigation = ((Selectable)button).navigation;
				((Navigation)(ref navigation)).mode = (Mode)4;
				((Navigation)(ref navigation)).selectOnUp = (Selectable)(object)((i > 0) ? rowsInVisualOrder[i - 1].Button : null);
				((Navigation)(ref navigation)).selectOnDown = (Selectable)(object)((i < rowsInVisualOrder.Count - 1) ? rowsInVisualOrder[i + 1].Button : null);
				((Navigation)(ref navigation)).selectOnLeft = null;
				((Navigation)(ref navigation)).selectOnRight = null;
				((Selectable)button).navigation = navigation;
			}
			DrawableSuitsDiagnostics.Info($"RebuildNavigation complete. rowCount={rowsInVisualOrder.Count}; rows=[{DescribeRows(rowsInVisualOrder)}]");
		}

		private static List<MenuRow> GetRowsInVisualOrder(RectTransform panel)
		{
			List<MenuRow> list = CollectRows((Transform)(object)panel);
			list.Sort(CompareTopToBottom);
			return list;
		}

		private static List<MenuRow> CollectRows(Transform root)
		{
			List<MenuRow> list = new List<MenuRow>();
			if ((Object)(object)root == (Object)null)
			{
				return list;
			}
			Button[] componentsInChildren = ((Component)root).GetComponentsInChildren<Button>(true);
			foreach (Button val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeSelf)
				{
					continue;
				}
				RectTransform component = ((Component)val).GetComponent<RectTransform>();
				if (!((Object)(object)component == (Object)null))
				{
					string labelText = GetLabelText(((Component)val).gameObject);
					if (!string.IsNullOrWhiteSpace(labelText) || !(((Object)((Component)val).gameObject).name != "DrawableSuitsButton"))
					{
						list.Add(new MenuRow(((Component)val).gameObject, component, val, labelText));
					}
				}
			}
			return list;
		}

		private static string GetLabelText(GameObject gameObject)
		{
			TextMeshProUGUI val = FindPrimaryTmpLabel(gameObject.GetComponentsInChildren<TextMeshProUGUI>(true), null);
			if ((Object)(object)val != (Object)null)
			{
				return ((TMP_Text)val).text ?? string.Empty;
			}
			Text val2 = FindPrimaryLegacyLabel(gameObject.GetComponentsInChildren<Text>(true), null);
			if (!((Object)(object)val2 != (Object)null))
			{
				return string.Empty;
			}
			return val2.text ?? string.Empty;
		}

		private static MenuRow ChooseTemplateRow(List<MenuRow> rows)
		{
			return FindResumeRow(rows) ?? FindRowContaining(rows, "invite") ?? FindRowContaining(rows, "settings") ?? FindRowContaining(rows, "lethalconfig") ?? FirstNonDrawableRow(rows);
		}

		private static MenuRow FindResumeRow(List<MenuRow> rows)
		{
			return FindRowContaining(rows, "resume");
		}

		private static MenuRow FindRowContaining(List<MenuRow> rows, string token)
		{
			foreach (MenuRow row in rows)
			{
				if (!row.IsDrawable && Normalize(row.LabelText).Contains(token))
				{
					return row;
				}
			}
			return null;
		}

		private static MenuRow FirstNonDrawableRow(List<MenuRow> rows)
		{
			foreach (MenuRow row in rows)
			{
				if (!row.IsDrawable)
				{
					return row;
				}
			}
			return null;
		}

		private static MenuRow FindRowFor(GameObject gameObject, List<MenuRow> rows)
		{
			foreach (MenuRow row in rows)
			{
				if ((Object)(object)row.GameObject == (Object)(object)gameObject)
				{
					return row;
				}
			}
			return null;
		}

		private static int CompareTopToBottom(MenuRow a, MenuRow b)
		{
			//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_0019: Unknown result type (might be due to invalid IL or missing references)
			int num = b.RectTransform.anchoredPosition.y.CompareTo(a.RectTransform.anchoredPosition.y);
			if (num == 0)
			{
				return ((Transform)a.RectTransform).GetSiblingIndex().CompareTo(((Transform)b.RectTransform).GetSiblingIndex());
			}
			return num;
		}

		private static string Normalize(string value)
		{
			return (value ?? string.Empty).Replace(" ", string.Empty).Replace("\n", string.Empty).ToLowerInvariant();
		}

		private static TextMeshProUGUI FindPrimaryTmpLabel(TextMeshProUGUI[] labels, string preferredText)
		{
			TextMeshProUGUI result = null;
			float num = float.MinValue;
			string preferred = Normalize(preferredText);
			foreach (TextMeshProUGUI val in labels)
			{
				if (!((Object)(object)val == (Object)null))
				{
					float num2 = ScoreLabelCandidate(((TMP_Text)val).text, ((TMP_Text)val).rectTransform, ((TMP_Text)val).fontSize, preferred);
					if (num2 > num)
					{
						num = num2;
						result = val;
					}
				}
			}
			return result;
		}

		private static Text FindPrimaryLegacyLabel(Text[] labels, string preferredText)
		{
			Text result = null;
			float num = float.MinValue;
			string preferred = Normalize(preferredText);
			foreach (Text val in labels)
			{
				if (!((Object)(object)val == (Object)null))
				{
					float num2 = ScoreLabelCandidate(val.text, ((Graphic)val).rectTransform, val.fontSize, preferred);
					if (num2 > num)
					{
						num = num2;
						result = val;
					}
				}
			}
			return result;
		}

		private static float ScoreLabelCandidate(string text, RectTransform rect, float fontSize, string preferred)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			string text2 = Normalize(text);
			if (string.IsNullOrEmpty(text2))
			{
				return -100000f;
			}
			float num = 0f;
			if (!string.IsNullOrEmpty(preferred) && text2.Contains(preferred))
			{
				num += 100000f;
			}
			num = ((!HasLetterOrDigit(text2)) ? (num - 1000f) : (num + (1000f + (float)text2.Length * 25f)));
			if ((Object)(object)rect != (Object)null)
			{
				float num2 = num;
				Rect rect2 = rect.rect;
				num = num2 + Mathf.Max(0f, ((Rect)(ref rect2)).width) * 0.2f;
				float num3 = num;
				rect2 = rect.rect;
				num = num3 + Mathf.Max(0f, ((Rect)(ref rect2)).height) * 0.1f;
			}
			return num + fontSize;
		}

		private static bool HasLetterOrDigit(string value)
		{
			for (int i = 0; i < value.Length; i++)
			{
				if (char.IsLetterOrDigit(value[i]))
				{
					return true;
				}
			}
			return false;
		}

		private static string DescribeTmpLabel(TextMeshProUGUI label)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)label == (Object)null))
			{
				return $"{((Object)((Component)label).gameObject).name}='{((TMP_Text)label).text}' rect={((TMP_Text)label).rectTransform.rect}";
			}
			return "none";
		}

		private static string DescribeLegacyLabel(Text label)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)label == (Object)null))
			{
				return $"{((Object)((Component)label).gameObject).name}='{label.text}' rect={((Graphic)label).rectTransform.rect}";
			}
			return "none";
		}

		private static string DescribeRect(RectTransform rect)
		{
			//IL_000f: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)rect == (Object)null))
			{
				return $"rect={rect.rect}; anchored={rect.anchoredPosition}; sizeDelta={rect.sizeDelta}";
			}
			return "rect=null";
		}

		private static string DescribeButtonColors(Button button)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_0042: 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_0060: 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)
			if ((Object)(object)button == (Object)null)
			{
				return "button=null";
			}
			ColorBlock colors = ((Selectable)button).colors;
			object[] obj = new object[7]
			{
				((Selectable)button).transition,
				((ColorBlock)(ref colors)).normalColor,
				((ColorBlock)(ref colors)).highlightedColor,
				((ColorBlock)(ref colors)).selectedColor,
				((ColorBlock)(ref colors)).pressedColor,
				((ColorBlock)(ref colors)).disabledColor,
				null
			};
			Graphic targetGraphic = ((Selectable)button).targetGraphic;
			obj[6] = ((targetGraphic != null) ? ((Object)targetGraphic).name : null) ?? "null";
			return string.Format("transition={0}; normal={1}; highlighted={2}; selected={3}; pressed={4}; disabled={5}; targetGraphic={6}", obj);
		}

		private static string DescribeNavigation(Button button)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)button == (Object)null)
			{
				return "button=null";
			}
			Navigation navigation = ((Selectable)button).navigation;
			object arg = ((Navigation)(ref navigation)).mode;
			Selectable selectOnUp = ((Navigation)(ref navigation)).selectOnUp;
			string arg2 = ((selectOnUp != null) ? ((Object)((Component)selectOnUp).gameObject).name : null) ?? "null";
			Selectable selectOnDown = ((Navigation)(ref navigation)).selectOnDown;
			return string.Format("mode={0}; up={1}; down={2}", arg, arg2, ((selectOnDown != null) ? ((Object)((Component)selectOnDown).gameObject).name : null) ?? "null");
		}

		private static void OpenEditorFromPauseMenu(QuickMenuManager quickMenu)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			DrawableSuitsDiagnostics.Info($"Pause-menu DrawableSuits button clicked. quickMenuNull={(Object)(object)quickMenu == (Object)null}; menuOpenBeforeClose={quickMenu?.isMenuOpen}; cursorVisible={Cursor.visible}; cursorLock={Cursor.lockState}");
			try
			{
				if (quickMenu != null)
				{
					quickMenu.CloseQuickMenu();
				}
				DrawableSuitsDiagnostics.Info($"Quick menu close requested. menuOpenAfterClose={quickMenu?.isMenuOpen}");
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception("Failed to close quick menu before opening editor", exception);
			}
			bool flag = DrawableSuitsPlugin.EnsureRuntimeReady("PauseMenuButton.Click");
			string text = DrawableSuitsPlugin.DescribeUnityObject((Object)(object)DrawableSuitsPlugin.Editor);
			if (flag && (Object)(object)DrawableSuitsPlugin.Editor != (Object)null)
			{
				DrawableSuitsPlugin.Editor.OpenFromPauseMenuNextFrame(quickMenu);
				DrawableSuitsDiagnostics.Info($"Pause-menu delayed open scheduled. runtimeReady={flag}; editorBefore={text}; editorAfter={DrawableSuitsPlugin.DescribeUnityObject((Object)(object)DrawableSuitsPlugin.Editor)}; cursorVisible={Cursor.visible}; cursorLock={Cursor.lockState}");
			}
			else
			{
				DrawableSuitsDiagnostics.Warn($"Pause-menu open could not be scheduled. runtimeReady={flag}; editorBefore={text}; editorAfter={DrawableSuitsPlugin.DescribeUnityObject((Object)(object)DrawableSuitsPlugin.Editor)}");
			}
		}

		private static string DescribeRows(List<MenuRow> rows)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (rows == null || rows.Count == 0)
			{
				return string.Empty;
			}
			List<string> list = new List<string>();
			foreach (MenuRow row in rows)
			{
				list.Add($"{row.LabelText}/{((Object)row.GameObject).name}@{row.RectTransform.anchoredPosition}");
			}
			return string.Join(", ", list);
		}
	}
	internal static class PluginInfo
	{
		public const string Guid = "com.toxcgang.drawablesuits";

		public const string Name = "DrawableSuits";

		public const string Version = "0.5.77";
	}
	internal static class SessionSafetyGuard
	{
		private static float _lastFullLogTime;

		internal static void Run(string reason, bool forceLog = false)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				bool isEditorOpen = DrawableSuitsPlugin.IsEditorOpen;
				int num = 0;
				if (!isEditorOpen)
				{
					if ((Object)(object)DrawableSuitsPlugin.Editor != (Object)null)
					{
						num += DrawableSuitsPlugin.Editor.RepairClosedEditorState(reason);
					}
					if ((Object)(object)DrawableSuitsPlugin.Registry != (Object)null)
					{
						num += DrawableSuitsPlugin.Registry.RestoreLocalPlayerMaterials("SessionSafetyCheck:" + reason);
					}
				}
				if (forceLog || num > 0 || Time.unscaledTime - _lastFullLogTime >= 2.5f)
				{
					_lastFullLogTime = Time.unscaledTime;
					Scene activeScene = SceneManager.GetActiveScene();
					PlayerControllerB localPlayer = GetLocalPlayer();
					DrawableSuitsDiagnostics.Info($"SessionSafetyCheck reason={reason}; scene={((Scene)(ref activeScene)).name}; editorOpen={isEditorOpen}; repaired={num}; " + "mainCamera=" + DescribeCamera(Camera.main) + "; activeCameras=[" + DescribeCameras() + "]; localPlayer=[" + DescribeLocalPlayer(localPlayer) + "]; prompt=[" + DescribePrompt(localPlayer) + "]; localRenderers=[" + DescribeLocalRenderers(localPlayer) + "]");
				}
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception("SessionSafetyCheck failed. reason=" + reason, exception);
			}
		}

		private static PlayerControllerB GetLocalPlayer()
		{
			PlayerControllerB val = StartOfRound.Instance?.localPlayerController;
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			try
			{
				return Object.FindObjectOfType<GameNetworkManager>()?.localPlayerController;
			}
			catch
			{
				return null;
			}
		}

		private static string DescribeCameras()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			Camera[] allCameras = Camera.allCameras;
			if (allCameras == null || allCameras.Length == 0)
			{
				return "none";
			}
			List<string> list = new List<string>();
			for (int i = 0; i < allCameras.Length; i++)
			{
				if (list.Count >= 24)
				{
					break;
				}
				Camera val = allCameras[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				GameObject gameObject = ((Component)val).gameObject;
				if (!((Object)(object)gameObject == (Object)null))
				{
					bool num = ((Object)gameObject).name.IndexOf("DrawableSuits", StringComparison.OrdinalIgnoreCase) >= 0;
					Scene scene = gameObject.scene;
					bool flag = ((Scene)(ref scene)).IsValid() && gameObject.activeInHierarchy;
					if (num || ((Behaviour)val).enabled || flag)
					{
						list.Add(DescribeCamera(val));
					}
				}
			}
			if (list.Count <= 0)
			{
				return "none";
			}
			return string.Join(" | ", list);
		}

		private static string DescribeCamera(Camera camera)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)camera == (Object)null)
			{
				return "null";
			}
			GameObject gameObject = ((Component)camera).gameObject;
			object[] obj = new object[10]
			{
				((Object)gameObject).name,
				((Behaviour)camera).enabled,
				gameObject.activeInHierarchy,
				null,
				null,
				null,
				null,
				null,
				null,
				null
			};
			Scene scene = gameObject.scene;
			obj[3] = ((Scene)(ref scene)).name;
			obj[4] = camera.depth;
			obj[5] = camera.clearFlags;
			obj[6] = (((Object)(object)camera.targetTexture != (Object)null) ? ((Object)camera.targetTexture).name : "none");
			obj[7] = camera.cullingMask;
			obj[8] = camera.nearClipPlane;
			obj[9] = camera.farClipPlane;
			return string.Format("{0}:enabled={1}:active={2}:scene={3}:depth={4:0.##}:clear={5}:target={6}:mask={7}:near={8:0.###}:far={9:0.###}", obj);
		}

		private static string DescribeLocalPlayer(PlayerControllerB player)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return "null";
			}
			return string.Format("{0}:pos={1}:moveDisabled={2}:lookDisabled={3}:interactDisabled={4}:specialMenu={5}:controlled={6}:dead={7}", ((Object)player).name, FormatVector(((Component)player).transform.position), player.disableMoveInput, player.disableLookInput, player.disableInteract, player.inSpecialMenu, DescribeMember(player, "isPlayerControlled"), DescribeMember(player, "isPlayerDead"));
		}

		private static string DescribePrompt(PlayerControllerB player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return "localPlayer=null";
			}
			StringBuilder stringBuilder = new StringBuilder();
			AppendMember(stringBuilder, player, "hoveringOverTrigger");
			AppendMember(stringBuilder, player, "currentlyGrabbingObject");
			AppendMember(stringBuilder, player, "currentlyHeldObjectServer");
			AppendMember(stringBuilder, player, "currentlyHeldObject");
			AppendMember(stringBuilder, player, "isGrabbingObjectAnimation");
			AppendMember(stringBuilder, player, "isTypingChat");
			if (stringBuilder.Length <= 0)
			{
				return "none";
			}
			return stringBuilder.ToString();
		}

		private static string DescribeLocalRenderers(PlayerControllerB player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return "localPlayer=null";
			}
			StringBuilder stringBuilder = new StringBuilder();
			AppendRenderer(stringBuilder, "body", (Renderer)(object)player.thisPlayerModel);
			AppendRenderer(stringBuilder, "lod1", (Renderer)(object)player.thisPlayerModelLOD1);
			AppendRenderer(stringBuilder, "lod2", (Renderer)(object)player.thisPlayerModelLOD2);
			AppendRenderer(stringBuilder, "arms", (Renderer)(object)player.thisPlayerModelArms);
			if (stringBuilder.Length <= 0)
			{
				return "none";
			}
			return stringBuilder.ToString();
		}

		private static void AppendRenderer(StringBuilder builder, string label, Renderer renderer)
		{
			if (builder.Length > 0)
			{
				builder.Append(" | ");
			}
			if ((Object)(object)renderer == (Object)null)
			{
				builder.Append(label).Append("=null");
				return;
			}
			Material sharedMaterial = renderer.sharedMaterial;
			builder.Append(label).Append("=").Append(((Object)renderer).name)
				.Append(":enabled=")
				.Append(renderer.enabled)
				.Append(":active=")
				.Append(((Component)renderer).gameObject.activeInHierarchy)
				.Append(":layer=")
				.Append(((Component)renderer).gameObject.layer)
				.Append(":material=")
				.Append(((Object)(object)sharedMaterial != (Object)null) ? ((Object)sharedMaterial).name : "null");
		}

		private static void AppendMember(StringBuilder builder, object target, string memberName)
		{
			string text = DescribeMember(target, memberName);
			if (!string.Equals(text, "<missing>", StringComparison.Ordinal))
			{
				if (builder.Length > 0)
				{
					builder.Append(" | ");
				}
				builder.Append(memberName).Append("=").Append(text);
			}
		}

		private static string DescribeMember(object target, string memberName)
		{
			if (target == null)
			{
				return "null";
			}
			try
			{
				Type type = target.GetType();
				FieldInfo field = type.GetField(memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field != null)
				{
					return FormatObject(field.GetValue(target));
				}
				PropertyInfo property = type.GetProperty(memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (property != null && property.GetIndexParameters().Length == 0)
				{
					return FormatObject(property.GetValue(target, null));
				}
			}
			catch (Exception ex)
			{
				return "<error:" + ex.GetType().Name + ">";
			}
			return "<missing>";
		}

		private static string FormatObject(object value)
		{
			//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_0029: 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_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)
			if (value == null)
			{
				return "null";
			}
			Object val = (Object)((value is Object) ? value : null);
			if (val != null)
			{
				return DrawableSuitsPlugin.DescribeUnityObject(val);
			}
			if (value is Vector3 value2)
			{
				return FormatVector(value2);
			}
			if (value is Vector2 val2)
			{
				return $"({val2.x:0.###},{val2.y:0.###})";
			}
			return value.ToString();
		}

		private static string FormatVector(Vector3 value)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			return $"({value.x:0.###},{value.y:0.###},{value.z:0.###})";
		}
	}
	[Serializable]
	internal sealed class SuitDesignMetadata
	{
		public string version;

		public string name;

		public string baseSuitName;

		public int sourceSuitId;

		public string textureFile;

		public int width;

		public int height;

		public string createdUtc;

		public string updatedUtc;
	}
	internal sealed class SuitEditorController : MonoBehaviour
	{
		private enum EditorCloseReason
		{
			Normal,
			Shortcut,
			PauseMenu,
			SceneChange,
			PluginDestroy
		}

		private enum EditorTool
		{
			Paint,
			Erase,
			FillBucket,
			Decal,
			Eyedropper,
			Text,
			Sticker
		}

		private enum CursorVisualMode
		{
			Dot,
			BrushRing,
			BrushSquare,
			BrushPixel
		}

		private enum BrushShape
		{
			Circle,
			Square,
			Pixel,
			SprayPaint,
			SoftAirbrush,
			NoiseScatter
		}

		private enum StickerShape
		{
			Circle,
			Square,
			Triangle,
			Diamond,
			Star,
			Heart,
			Arrow,
			LightningBolt,
			Plus,
			Ring,
			Crescent,
			Shield
		}

		private sealed class RotatedUvRawImage : RawImage
		{
			private int _quarterTurns;

			internal void SetUvRotation(int quarterTurns)
			{
				int num = NormalizeUvPanelRotation(quarterTurns);
				if (_quarterTurns != num)
				{
					_quarterTurns = num;
					((Graphic)this).SetVerticesDirty();
				}
			}

			protected override void OnPopulateMesh(VertexHelper vh)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_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_006f: 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_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: Unknown result type (might be due to invalid IL or missing references)
				//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)
				Rect pixelAdjustedRect = ((Graphic)this).GetPixelAdjustedRect();
				Color color = ((Graphic)this).color;
				Rect uvRect = ((RawImage)this).uvRect;
				vh.Clear();
				vh.AddVert(new Vector3(((Rect)(ref pixelAdjustedRect)).xMin, ((Rect)(ref pixelAdjustedRect)).yMin), Color32.op_Implicit(color), Vector4.op_Implicit(UvForPanelPoint(new Vector2(0f, 0f), uvRect, _quarterTurns)));
				vh.AddVert(new Vector3(((Rect)(ref pixelAdjustedRect)).xMin, ((Rect)(ref pixelAdjustedRect)).yMax), Color32.op_Implicit(color), Vector4.op_Implicit(UvForPanelPoint(new Vector2(0f, 1f), uvRect, _quarterTurns)));
				vh.AddVert(new Vector3(((Rect)(ref pixelAdjustedRect)).xMax, ((Rect)(ref pixelAdjustedRect)).yMax), Color32.op_Implicit(color), Vector4.op_Implicit(UvForPanelPoint(new Vector2(1f, 1f), uvRect, _quarterTurns)));
				vh.AddVert(new Vector3(((Rect)(ref pixelAdjustedRect)).xMax, ((Rect)(ref pixelAdjustedRect)).yMin), Color32.op_Implicit(color), Vector4.op_Implicit(UvForPanelPoint(new Vector2(1f, 0f), uvRect, _quarterTurns)));
				vh.AddTriangle(0, 1, 2);
				vh.AddTriangle(2, 3, 0);
			}

			private static Vector2 UvForPanelPoint(Vector2 panelPoint, Rect view, int quarterTurns)
			{
				//IL_0000: 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)
				//IL_000f: 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_0034: Unknown result type (might be due to invalid IL or missing references)
				Vector2 val = PanelNormalizedToViewNormalized(panelPoint, quarterTurns);
				return new Vector2(((Rect)(ref view)).xMin + val.x * ((Rect)(ref view)).width, ((Rect)(ref view)).yMin + val.y * ((Rect)(ref view)).height);
			}
		}

		private enum PlacementEditTarget
		{
			None,
			Decal,
			Sticker
		}

		private enum PlacementFilter
		{
			None,
			Grayscale,
			Invert,
			Sepia,
			Brightness,
			Contrast,
			Saturation,
			HueShift
		}

		private enum ToolIconKind
		{
			Paint,
			Erase,
			Fill,
			Decal,
			Text,
			Eyedropper,
			Mirror,
			Sticker
		}

		private sealed class EventSystemRestoreState
		{
			internal EventSystem EventSystem;

			internal bool GameObjectActive;

			internal bool EventSystemEnabled;

			internal BaseInputModule[] Modules;

			internal bool[] ModuleEnabled;
		}

		private sealed class PlacementEditState
		{
			internal float CropLeft;

			internal float CropRight;

			internal float CropBottom;

			internal float CropTop;

			internal float StretchX = 1f;

			internal float StretchY = 1f;

			internal bool FlipX;

			internal bool FlipY;

			internal float GrayscaleAmount;

			internal float InvertAmount;

			internal float SepiaAmount;

			internal float BrightnessAmount;

			internal float ContrastAmount;

			internal float SaturationAmount;

			internal float HueShiftAmount;

			internal int Revision;

			internal bool IsDefault
			{
				get
				{
					if (CropLeft <= 0.0001f && CropRight <= 0.0001f && CropBottom <= 0.0001f && CropTop <= 0.0001f && Mathf.Abs(StretchX - 1f) <= 0.0001f && Mathf.Abs(StretchY - 1f) <= 0.0001f && !FlipX && !FlipY)
					{
						return !HasActiveFilters;
					}
					return false;
				}
			}

			internal bool HasActiveFilters
			{
				get
				{
					if (!(GrayscaleAmount > 0.0001f) && !(InvertAmount > 0.0001f) && !(SepiaAmount > 0.0001f) && !(BrightnessAmount > 0.0001f) && !(ContrastAmount > 0.0001f) && !(SaturationAmount > 0.0001f))
					{
						return HueShiftAmount > 0.0001f;
					}
					return true;
				}
			}

			internal void Reset()
			{
				CropLeft = 0f;
				CropRight = 0f;
				CropBottom = 0f;
				CropTop = 0f;
				StretchX = 1f;
				StretchY = 1f;
				FlipX = false;
				FlipY = false;
				GrayscaleAmount = 0f;
				InvertAmount = 0f;
				SepiaAmount = 0f;
				BrightnessAmount = 0f;
				ContrastAmount = 0f;
				SaturationAmount = 0f;
				HueShiftAmount = 0f;
				Revision++;
			}

			internal Rect CropRect(float minSize)
			{
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				float num = Mathf.Clamp01(CropLeft);
				float num2 = Mathf.Clamp01(CropRight);
				float num3 = Mathf.Clamp01(CropBottom);
				float num4 = Mathf.Clamp01(CropTop);
				if (num + num2 > 1f - minSize)
				{
					float num5 = (1f - minSize) / Mathf.Max(0.0001f, num + num2);
					num *= num5;
					num2 *= num5;
				}
				if (num3 + num4 > 1f - minSize)
				{
					float num6 = (1f - minSize) / Mathf.Max(0.0001f, num3 + num4);
					num3 *= num6;
					num4 *= num6;
				}
				return new Rect(num, num3, Mathf.Max(minSize, 1f - num - num2), Mathf.Max(minSize, 1f - num3 - num4));
			}

			internal string Key()
			{
				return $"crop={CropLeft:0.####},{CropRight:0.####},{CropBottom:0.####},{CropTop:0.####}|stretch={StretchX:0.###},{StretchY:0.###}|flip={FlipX},{FlipY}|filters={GrayscaleAmount:0.###},{SepiaAmount:0.###},{InvertAmount:0.###},{BrightnessAmount:0.###},{ContrastAmount:0.###},{SaturationAmount:0.###},{HueShiftAmount:0.###}|rev={Revision}";
			}

			internal float GetFilterAmount(PlacementFilter filter)
			{
				return filter switch
				{
					PlacementFilter.Grayscale => GrayscaleAmount, 
					PlacementFilter.Invert => InvertAmount, 
					PlacementFilter.Sepia => SepiaAmount, 
					PlacementFilter.Brightness => BrightnessAmount, 
					PlacementFilter.Contrast => ContrastAmount, 
					PlacementFilter.Saturation => SaturationAmount, 
					PlacementFilter.HueShift => HueShiftAmount, 
					_ => 0f, 
				};
			}

			internal void SetFilterAmount(PlacementFilter filter, float amount)
			{
				amount = Mathf.Clamp01(amount);
				switch (filter)
				{
				case PlacementFilter.Grayscale:
					GrayscaleAmount = amount;
					break;
				case PlacementFilter.Invert:
					InvertAmount = amount;
					break;
				case PlacementFilter.Sepia:
					SepiaAmount = amount;
					break;
				case PlacementFilter.Brightness:
					BrightnessAmount = amount;
					break;
				case PlacementFilter.Contrast:
					ContrastAmount = amount;
					break;
				case PlacementFilter.Saturation:
					SaturationAmount = amount;
					break;
				case PlacementFilter.HueShift:
					HueShiftAmount = amount;
					break;
				}
			}
		}

		private sealed class PlacementSourcePixelCache
		{
			internal PlacementEditTarget Target;

			internal Texture2D Source;

			internal string SourceName = string.Empty;

			internal int Width;

			internal int Height;

			internal Color32[] Pixels;
		}

		private sealed class PlacementEditSnapshot
		{
			internal float CropLeft;

			internal float CropRight;

			internal float CropBottom;

			internal float CropTop;

			internal float StretchX = 1f;

			internal float StretchY = 1f;

			internal bool FlipX;

			internal bool FlipY;

			internal float GrayscaleAmount;

			internal float InvertAmount;

			internal float SepiaAmount;

			internal float BrightnessAmount;

			internal float ContrastAmount;

			internal float SaturationAmount;

			internal float HueShiftAmount;

			internal int Revision;

			internal string Key = string.Empty;

			internal bool HasActiveFilters
			{
				get
				{
					if (!(GrayscaleAmount > 0.0001f) && !(InvertAmount > 0.0001f) && !(SepiaAmount > 0.0001f) && !(BrightnessAmount > 0.0001f) && !(ContrastAmount > 0.0001f) && !(SaturationAmount > 0.0001f))
					{
						return HueShiftAmount > 0.0001f;
					}
					return true;
				}
			}

			internal static PlacementEditSnapshot From(PlacementEditState state)
			{
				return new PlacementEditSnapshot
				{
					CropLeft = (state?.CropLeft ?? 0f),
					CropRight = (state?.CropRight ?? 0f),
					CropBottom = (state?.CropBottom ?? 0f),
					CropTop = (state?.CropTop ?? 0f),
					StretchX = (state?.StretchX ?? 1f),
					StretchY = (state?.StretchY ?? 1f),
					FlipX = (state?.FlipX ?? false),
					FlipY = (state?.FlipY ?? false),
					GrayscaleAmount = (state?.GrayscaleAmount ?? 0f),
					InvertAmount = (state?.InvertAmount ?? 0f),
					SepiaAmount = (state?.SepiaAmount ?? 0f),
					BrightnessAmount = (state?.BrightnessAmount ?? 0f),
					ContrastAmount = (state?.ContrastAmount ?? 0f),
					SaturationAmount = (state?.SaturationAmount ?? 0f),
					HueShiftAmount = (state?.HueShiftAmount ?? 0f),
					Revision = (state?.Revision ?? 0),
					Key = (state?.Key() ?? string.Empty)
				};
			}
		}

		private sealed class RendererRestoreState
		{
			internal Renderer Renderer;

			internal bool Enabled;

			internal int Layer;

			internal bool UpdateWhenOffscreen;

			internal bool HasUpdateWhenOffscreen;
		}

		private sealed class AnchoredListRow
		{
			internal Button Button;

			internal Text Label;

			internal Image Image;

			internal int Index = -1;
		}

		private sealed class UndoHistoryEntry
		{
			internal long Id;

			internal Color32[] Pixels;

			internal string Label;
		}

		private sealed class UndoHistoryRow
		{
			internal GameObject GameObject;

			internal Button Button;

			internal Text Label;

			internal Image Image;

			internal int Index = -1;

			internal long EntryId;
		}

		private struct MirrorPaintTarget
		{
			internal bool Enabled;

			internal bool Available;

			internal Vector2 Uv;

			internal Vector3 PrimaryLocalPoint;

			internal Vector3 ReflectedLocalPoint;

			internal Vector3 MirroredLocalPoint;

			internal Vector3 MirroredLocalNormal;

			internal float Distance;

			internal int TriangleIndex;

			internal string Mode;

			internal string Reason;
		}

		private struct MirrorLookupResult
		{
			internal Vector2 Uv;

			internal Vector3 LocalPoint;

			internal Vector3 ReflectedLocalPoint;

			internal Vector3 LocalNormal;

			internal float Distance;

			internal int TriangleIndex;

			internal string Reason;
		}

		private struct TextProjectionFrame
		{
			internal Vector3 Center;

			internal Vector3 Normal;

			internal Vector3 Right;

			internal Vector3 Up;

			internal float WorldWidth;

			internal float WorldHeight;
		}

		private struct TextSurfaceStampStats
		{
			internal int AlphaPixels;

			internal int WrittenPixels;

			internal int SkippedPixels;

			internal int ProjectionSamples;

			internal int AcceptedSamples;

			internal int SurfaceHits;

			internal int RasterizedCells;

			internal int SeamSkippedCells;

			internal int OffSuitSamples;

			internal int RandomSkippedSamples;

			internal float WorldWidth;

			internal float WorldHeight;

			internal bool Mirrored;
		}

		private struct FillBucketStats
		{
			internal int CheckedPixels;

			internal int MatchedPixels;

			internal int WrittenPixels;

			internal int TouchedSkippedPixels;

			internal Vector2Int SeedPixel;

			internal Color32 SeedColor;

			internal bool Mirrored;
		}

		private struct BrushShapeStats
		{
			internal bool Available;

			internal int CheckedSamples;

			internal int AcceptedSamples;

			internal int RandomSkippedSamples;

			internal int WrittenPixels;

			internal bool Mirrored;
		}

		private struct SurfaceStampSample
		{
			internal Color Color;

			internal float Alpha;
		}

		private struct SurfaceStampGridSample
		{
			internal bool Valid;

			internal Vector2 StampUv;

			internal Vector2 SurfaceUv;

			internal Vector2 Pixel;

			internal float Alpha;
		}

		private sealed class MirrorSurfaceMap
		{
			private readonly MirrorTriangle[] _triangles;

			private readonly Bounds _bounds;

			private readonly float _mirrorPlaneX;

			private readonly float _maxMirrorDistance;

			internal string Key { get; }

			internal int TriangleCount => _triangles.Length;

			internal Bounds Bounds => _bounds;

			internal float MirrorPlaneX => _mirrorPlaneX;

			private MirrorSurfaceMap(string key, MirrorTriangle[] triangles, Bounds bounds)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: 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)
				Key = key;
				_triangles = triangles;
				_bounds = bounds;
				_mirrorPlaneX = ((Bounds)(ref bounds)).center.x;
				Vector3 size = ((Bounds)(ref bounds)).size;
				_maxMirrorDistance = Mathf.Max(0.35f, ((Vector3)(ref size)).magnitude * 0.28f);
			}

			internal static MirrorSurfaceMap Build(Mesh mesh, string key)
			{
				//IL_0211: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_0102: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_0113: 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_0117: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0120: Unknown result type (might be due to invalid IL or missing references)
				//IL_0144: Unknown result type (might be due to invalid IL or missing references)
				//IL_0146: Unknown result type (might be due to invalid IL or missing references)
				//IL_014d: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0156: 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_015f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0161: Unknown result type (might be due to invalid IL or missing references)
				//IL_0168: Unknown result type (might be due to invalid IL or missing references)
				//IL_016a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0171: Unknown result type (might be due to invalid IL or missing references)
				//IL_0173: Unknown result type (might be due to invalid IL or missing references)
				//IL_017a: Unknown result type (might be due to invalid IL or missing references)
				//IL_017c: Unknown result type (might be due to invalid IL or missing references)
				//IL_017e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0183: Unknown result type (might be due to invalid IL or missing references)
				//IL_0185: Unknown result type (might be due to invalid IL or missing references)
				//IL_018f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0194: Unknown result type (might be due to invalid IL or missing references)
				//IL_019b: 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_019f: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_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)
				//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)mesh == (Object)null || mesh.vertexCount == 0)
				{
					return null;
				}
				Vector3[] vertices = mesh.vertices;
				Vector2[] uv = mesh.uv;
				if (uv == null || uv.Length < vertices.Length)
				{
					return null;
				}
				List<MirrorTriangle> list = new List<MirrorTriangle>();
				int num = 0;
				int num2 = Mathf.Max(1, mesh.subMeshCount);
				for (int i = 0; i < num2; i++)
				{
					int[] triangles = mesh.GetTriangles(i);
					for (int j = 0; j + 2 < triangles.Length; j += 3)
					{
						int num3 = triangles[j];
						int num4 = triangles[j + 1];
						int num5 = triangles[j + 2];
						if (num3 < 0 || num4 < 0 || num5 < 0 || num3 >= vertices.Length || num4 >= vertices.Length || num5 >= vertices.Length)
						{
							continue;
						}
						Vector3 val = vertices[num3];
						Vector3 val2 = vertices[num4];
						Vector3 val3 = vertices[num5];
						Vector3 val4 = Vector3.Cross(val2 - val, val3 - val);
						if (!(((Vector3)(ref val4)).sqrMagnitude < 1E-07f))
						{
							Vector2 val5 = uv[num3];
							Vector2 val6 = uv[num4];
							Vector2 val7 = uv[num5];
							if (!(Mathf.Abs(Cross2D(val6 - val5, val7 - val5)) < 1E-07f))
							{
								MirrorTriangle item = new MirrorTriangle
								{
									A = val,
									B = val2,
									C = val3,
									UvA = val5,
									UvB = val6,
									UvC = val7,
									Centroid = (val + val2 + val3) / 3f
								};
								val4 = Vector3.Cross(val2 - val, val3 - val);
								item.Normal = ((Vector3)(ref val4)).normalized;
								item.SubMesh = i;
								item.TriangleIndex = num;
								list.Add(item);
								num++;
							}
						}
					}
				}
				if (list.Count <= 0)
				{
					return null;
				}
				return new MirrorSurfaceMap(key, list.ToArray(), mesh.bounds);
			}

			internal bool TryMirrorFromLocalPoint(Vector3 primaryLocalPoint, out MirrorLookupResult result)
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: 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_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				result = default(MirrorLookupResult);
				if (_triangles.Length == 0)
				{
					result.Reason = "surface map empty";
					return false;
				}
				Vector3 reflectedLocalPoint = primaryLocalPoint;
				reflectedLocalPoint.x = _mirrorPlaneX * 2f - primaryLocalPoint.x;
				float num = primaryLocalPoint.x - _mirrorPlaneX;
				int targetSign = ((num > 0.001f) ? (-1) : ((num < -0.001f) ? 1 : 0));
				if (TryFindClosestTriangle(reflectedLocalPoint, targetSign, enforceDistance: true, out result))
				{
					result.ReflectedLocalPoint = reflectedLocalPoint;
					return true;
				}
				result.ReflectedLocalPoint = reflectedLocalPoint;
				if (string.IsNullOrWhiteSpace(result.Reason))
				{
					result.Reason = "no reliable opposite mirror target triangle";
				}
				return false;
			}

			internal bool TryLocalPointFromUv(Vector2 uv, out Vector3 localPoint, out int triangleIndex, out string reason)
			{
				//IL_0001: 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_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_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_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				localPoint = default(Vector3);
				triangleIndex = -1;
				reason = string.Empty;
				float num = float.MaxValue;
				bool flag = false;
				for (int i = 0; i < _triangles.Length; i++)
				{
					MirrorTriangle mirrorTriangle = _triangles[i];
					if (TryBarycentric2D(uv, mirrorTriangle.UvA, mirrorTriangle.UvB, mirrorTriangle.UvC, out var barycentric, 0.0015f))
					{
						float num2 = Mathf.Abs(Cross2D(mirrorTriangle.UvB - mirrorTriangle.UvA, mirrorTriangle.UvC - mirrorTriangle.UvA));
						if (!(num2 >= num))
						{
							num = num2;
							localPoint = mirrorTriangle.A * barycentric.x + mirrorTriangle.B * barycentric.y + mirrorTriangle.C * barycentric.z;
							triangleIndex = mirrorTriangle.TriangleIndex;
							flag = true;
						}
					}
				}
				reason = (flag ? "uv mapped to source triangle" : "uv did not map to any mesh triangle");
				return flag;
			}

			private bool TryFindClosestTriangle(Vector3 reflectedLocalPoint, int targetSign, bool enforceDistance, out MirrorLookupResult result)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: 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_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: 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_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: Unknown result type (might be due to invalid IL or missing references)
				//IL_0128: Unknown result type (might be due to invalid IL or missing references)
				//IL_0165: Unknown result type (might be due to invalid IL or missing references)
				//IL_016a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0171: Unknown result type (might be due to invalid IL or missing references)
				//IL_0177: Unknown result type (might be due to invalid IL or missing references)
				//IL_017c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0183: Unknown result type (might be due to invalid IL or missing references)
				//IL_0188: Unknown result type (might be due to invalid IL or missing references)
				//IL_018e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0193: Unknown result type (might be due to invalid IL or missing references)
				//IL_019a: Unknown result type (might be due to invalid IL or missing references)
				//IL_019f: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01be: Unknown result type (might be due to invalid IL or missing references)
				//IL_014e: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
				result = default(MirrorLookupResult);
				float num = float.MaxValue;
				MirrorTriangle mirrorTriangle = default(MirrorTriangle);
				Vector3 val = Vector3.zero;
				bool flag = false;
				for (int i = 0; i < _triangles.Length; i++)
				{
					MirrorTriangle mirrorTriangle2 = _triangles[i];
					if (targetSign == 0 || !((mirrorTriangle2.Centroid.x - _mirrorPlaneX) * (float)targetSign < -0.01f))
					{
						Vector3 val2 = ClosestPointOnTriangle(reflectedLocalPoint, mirrorTriangle2.A, mirrorTriangle2.B, mirrorTriangle2.C);
						Vector3 val3 = val2 - reflectedLocalPoint;
						float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
						if (!(sqrMagnitude >= num))
						{
							num = sqrMagnitude;
							mirrorTriangle = mirrorTriangle2;
							val = val2;
							flag = true;
						}
					}
				}
				if (!flag)
				{
					result.Reason = ((targetSign == 0) ? "no triangle candidates" : "no opposite-side triangle candidates");
					return false;
				}
				float num2 = Mathf.Sqrt(num);
				if (enforceDistance && num2 > _maxMirrorDistance)
				{
					result.Distance = num2;
					result.TriangleIndex = mirrorTriangle.TriangleIndex;
					result.LocalPoint = val;
					result.Reason = $"nearest candidate too far {num2:0.###}>{_maxMirrorDistance:0.###}";
					return false;
				}
				if (!TryBarycentric3D(val, mirrorTriangle.A, mirrorTriangle.B, mirrorTriangle.C, out var barycentric))
				{
					result.Distance = num2;
					result.TriangleIndex = mirrorTriangle.TriangleIndex;
					result.LocalPoint = val;
					result.Reason = "mirror triangle barycentric failed";
					return false;
				}
				result.Uv = ClampUv(mirrorTriangle.UvA * barycentric.x + mirrorTriangle.UvB * barycentric.y + mirrorTriangle.UvC * barycentric.z);
				result.LocalPoint = val;
				result.LocalNormal = mirrorTriangle.Normal;
				result.Distance = num2;
				result.TriangleIndex = mirrorTriangle.TriangleIndex;
				result.Reason = "surface map";
				return true;
			}
		}

		private struct MirrorTriangle
		{
			internal Vector3 A;

			internal Vector3 B;

			internal Vector3 C;

			internal Vector2 UvA;

			internal Vector2 UvB;

			internal Vector2 UvC;

			internal Vector3 Centroid;

			internal Vector3 Normal;

			internal int SubMesh;

			internal int TriangleIndex;
		}

		private struct WorldCameraState
		{
			internal bool Valid;

			internal float Yaw;

			internal float Pitch;

			internal float Distance;
		}

		private sealed class DrawableToolIconGraphic : Graphic
		{
			private ToolIconKind _kind;

			internal void Configure(ToolIconKind kind, Color iconColor)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				_kind = kind;
				((Graphic)this).color = iconColor;
				((Graphic)this).raycastTarget = false;
				((Graphic)this).SetVerticesDirty();
			}

			internal void SetIconColor(Color iconColor)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				((Graphic)this).color = iconColor;
				((Graphic)this).SetVerticesDirty();
			}

			protected override void OnPopulateMesh(VertexHelper vh)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: 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_0078: 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_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: 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_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0103: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_0144: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Unknown result type (might be due to invalid IL or missing references)
				//IL_015e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0169: Unknown result type (might be due to invalid IL or missing references)
				//IL_0174: Unknown result type (might be due to invalid IL or missing references)
				//IL_017f: Unknown result type (might be due to invalid IL or missing references)
				//IL_018e: 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_01a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01af: Unknown result type (might be due to invalid IL or missing references)
				//IL_01be: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0204: Unknown result type (might be due to invalid IL or missing references)
				//IL_0209: Unknown result type (might be due to invalid IL or missing references)
				//IL_021a: Unknown result type (might be due to invalid IL or missing references)
				//IL_021f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0230: Unknown result type (might be due to invalid IL or missing references)
				//IL_0235: Unknown result type (might be due to invalid IL or missing references)
				//IL_0240: Unknown result type (might be due to invalid IL or missing references)
				//IL_024b: Unknown result type (might be due to invalid IL or missing references)
				//IL_025a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0265: Unknown result type (might be due to invalid IL or missing references)
				//IL_0270: Unknown result type (might be due to invalid IL or missing references)
				//IL_027b: Unknown result type (might be due to invalid IL or missing references)
				//IL_028a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0295: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_030c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0317: Unknown result type (might be due to invalid IL or missing references)
				//IL_0322: Unknown result type (might be due to invalid IL or missing references)
				//IL_032d: Unknown result type (might be due to invalid IL or missing references)
				//IL_033c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0347: Unknown result type (might be due to invalid IL or missing references)
				//IL_0352: Unknown result type (might be due to invalid IL or missing references)
				//IL_035d: Unknown result type (might be due to invalid IL or missing references)
				//IL_036c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0377: Unknown result type (might be due to invalid IL or missing references)
				//IL_0382: Unknown result type (might be due to invalid IL or missing references)
				//IL_038d: Unknown result type (might be due to invalid IL or missing references)
				//IL_039c: Unknown result type (might be due to invalid IL or missing references)
				//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_03bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0402: Unknown result type (might be due to invalid IL or missing references)
				//IL_040e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0419: Unknown result type (might be due to invalid IL or missing references)
				//IL_0428: Unknown result type (might be due to invalid IL or missing references)
				//IL_042e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0439: Unknown result type (might be due to invalid IL or missing references)
				//IL_0444: Unknown result type (might be due to invalid IL or missing references)
				//IL_0453: Unknown result type (might be due to invalid IL or missing references)
				//IL_0459: Unknown result type (might be due to invalid IL or missing references)
				//IL_0464: Unknown result type (might be due to invalid IL or missing references)
				//IL_046f: Unknown result type (might be due to invalid IL or missing references)
				//IL_047e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0484: Unknown result type (might be due to invalid IL or missing references)
				//IL_0490: Unknown result type (might be due to invalid IL or missing references)
				//IL_049b: Unknown result type (might be due to invalid IL or missing references)
				//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_04be: Unknown result type (might be due to invalid IL or missing references)
				//IL_04cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_04d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_04e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_04ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_04fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0508: Unknown result type (might be due to invalid IL or missing references)
				//IL_0513: Unknown result type (might be due to invalid IL or missing references)
				//IL_0515: Unknown result type (might be due to invalid IL or missing references)
				//IL_052c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0531: Unknown result type (might be due to invalid IL or missing references)
				//IL_0542: Unknown result type (might be due to invalid IL or missing references)
				//IL_0547: Unknown result type (might be due to invalid IL or missing references)
				//IL_0558: Unknown result type (might be due to invalid IL or missing references)
				//IL_055d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0568: Unknown result type (might be due to invalid IL or missing references)
				//IL_0573: Unknown result type (might be due to invalid IL or missing references)
				//IL_057e: Unknown result type (might be due to invalid IL or missing references)
				//IL_058a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0595: Unknown result type (might be due to invalid IL or missing references)
				//IL_05a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_05af: Unknown result type (might be due to invalid IL or missing references)
				//IL_05ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_05c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_05d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_05df: Unknown result type (might be due to invalid IL or missing references)
				//IL_05ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_05f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_0604: Unknown result type (might be due to invalid IL or missing references)
				//IL_060f: Unknown result type (might be due to invalid IL or missing references)
				//IL_061a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0625: Unknown result type (might be due to invalid IL or missing references)
				//IL_0634: Unknown result type (might be due to invalid IL or missing references)
				//IL_063f: Unknown result type (might be due to invalid IL or missing references)
				//IL_064a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0655: Unknown result type (might be due to invalid IL or missing references)
				//IL_0664: Unknown result type (might be due to invalid IL or missing references)
				//IL_066f: Unknown result type (might be due to invalid IL or missing references)
				//IL_067a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0685: Unknown result type (might be due to invalid IL or missing references)
				//IL_0694: Unknown result type (might be due to invalid IL or missing references)
				//IL_069f: Unknown result type (might be due to invalid IL or missing references)
				//IL_06aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_06b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_06c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_06cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_06db: Unknown result type (might be due to invalid IL or missing references)
				//IL_06dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_06f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_06f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_070a: Unknown result type (might be due to invalid IL or missing references)
				//IL_070f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0720: Unknown result type (might be due to invalid IL or missing references)
				//IL_0725: Unknown result type (might be due to invalid IL or missing references)
				//IL_0736: Unknown result type (might be due to invalid IL or missing references)
				//IL_073b: Unknown result type (might be due to invalid IL or missing references)
				//IL_074c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0751: Unknown result type (might be due to invalid IL or missing references)
				//IL_075c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0771: Unknown result type (might be due to invalid IL or missing references)
				//IL_0788: Unknown result type (might be due to invalid IL or missing references)
				//IL_078d: Unknown result type (might be due to invalid IL or missing references)
				//IL_079e: Unknown result type (might be due to invalid IL or missing references)
				//IL_07a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_07b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_07b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_07c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_07cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_07da: Unknown result type (might be due to invalid IL or missing references)
				//IL_07e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_07e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0800: Unknown result type (might be due to invalid IL or missing references)
				//IL_0805: Unknown result type (might be due to invalid IL or missing references)
				//IL_0816: Unknown result type (might be due to invalid IL or missing references)
				//IL_081b: Unknown result type (might be due to invalid IL or missing references)
				//IL_082c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0831: Unknown result type (might be due to invalid IL or missing references)
				vh.Clear();
				Rect rect = ((Graphic)this).rectTransform.rect;
				if (!(((Rect)(ref rect)).width <= 0.1f) && !(((Rect)(ref rect)).height <= 0.1f))
				{
					switch (_kind)
					{
					case ToolIconKind.Paint:
						AddLine(vh, rect, new Vector2(-0.34f, -0.3f), new Vector2(0.03f, 0.07f), 0.075f, ((Graphic)this).color);
						AddRotatedBox(vh, rect, new Vector2(0.12f, 0.16f), new Vector2(0.22f, 0.11f), 45f, ((Graphic)this).color);
						AddPolygon(vh, rect, ((Graphic)this).color, new Vector2(0.2f, 0.22f), new Vector2(0.38f, 0.36f), new Vector2(0.31f, 0.09f));
						AddLine(vh, rect, new Vector2(-0.36f, -0.38f), new Vector2(-0.12f, -0.38f), 0.04f, ((Graphic)this).color);
						break;
					case ToolIconKind.Erase:
						AddLine(vh, rect, new Vector2(-0.26f, -0.05f), new Vector2(0.18f, 0.28f), 0.18f, ((Graphic)this).color);
						AddLine(vh, rect, new Vector2(-0.32f, -0.24f), new Vector2(0.22f, -0.24f), 0.045f, ((Graphic)this).color);
						AddLine(vh, rect, new Vector2(0.05f, -0.02f), new Vector2(0.24f, 0.12f), 0.04f, ((Graphic)this).color);
						break;
					case ToolIconKind.Fill:
						AddPolygon(vh, rect, ((Graphic)this).color, new Vector2(-0.3f, 0.18f), new Vector2(0.11f, 0.31f), new Vector2(0.3f, -0.05f), new Vector2(-0.12f, -0.23f));
						AddLine(vh, rect, new Vector2(-0.23f, 0.25f), new Vector2(0.02f, 0.34f), 0.04f, ((Graphic)this).color);
						AddLine(vh, rect, new Vector2(-0.02f, -0.18f), new Vector2(0.29f, -0.3f), 0.055f, ((Graphic)this).color);
						AddDrop(vh, rect, new Vector2(0.34f, -0.36f), 0.07f, ((Graphic)this).color);
						break;
					case ToolIconKind.Decal:
						AddLine(vh, rect, new Vector2(-0.32f, -0.28f), new Vector2(0.32f, -0.28f), 0.045f, ((Graphic)this).color);
						AddLine(vh, rect, new Vector2(-0.32f, 0.28f), new Vector2(0.32f, 0.28f), 0.045f, ((Graphic)this).color);
						AddLine(vh, rect, new Vector2(-0.32f, -0.28f), new Vector2(-0.32f, 0.28f), 0.045f, ((Graphic)this).color);
						AddLine(vh, rect, new Vector2(0.32f, -0.28f), new Vector2(0.32f, 0.28f), 0.045f, ((Graphic)this).color);
						AddLine(vh, rect, new Vector2(-0.22f, -0.18f), new Vector2(-0.02f, 0.08f), 0.04f, ((Graphic)this).color);
						AddLine(vh, rect, new Vector2(-0.02f, 0.08f), new Vector2(0.24f, -0.18f), 0.04f, ((Graphic)this).color);
						AddBox(vh, rect, new Vector2(0.16f, 0.12f), new Vector2(0.08f, 0.08f), ((Graphic)this).color);
						break;
					case ToolIconKind.Text:
						AddBox(vh, rect, new Vector2(0f, 0.28f), new Vector2(0.56f, 0.08f), ((Graphic)this).color);
						AddBox(vh, rect, new Vector2(0f, 0f), new Vector2(0.1f, 0.64f), ((Graphic)this).color);
						AddBox(vh, rect, new Vector2(0f, -0.32f), new Vector2(0.28f, 0.07f), ((Graphic)this).color);
						break;
					case ToolIconKind.Eyedropper:
						AddFilledCircle(vh, rect, new Vector2(0.25f, 0.28f), 0.085f, ((Graphic)this).color);
						AddLine(vh, rect, new Vector2(0.18f, 0.2f), new Vector2(-0.18f, -0.16f), 0.08f, ((Graphic)this).color);
						AddLine(vh, rect, new Vector2(0.04f, 0.24f), new Vector2(0.29f, -0.01f), 0.045f, ((Graphic)this).color);
						AddPolygon(vh, rect, ((Graphic)this).color, new Vector2(-0.19f, -0.17f), new Vector2(-0.33f, -0.34f), new Vector2(-0.12f, -0.25f));
						AddDrop(vh, rect, new Vector2(-0.36f, -0.39f), 0.045f, ((Graphic)this).color);
						break;
					case ToolIconKind.Mirror:
						AddLine(vh, rect, new Vector2(0f, -0.34f), new Vector2(0f, 0.34f), 0.045f, ((Graphic)this).color);
						AddLine(vh, rect, new Vector2(-0.32f, 0.12f), new Vector2(-0.08f, 0.12f), 0.055f, ((Graphic)this).color);
						AddLine(vh, rect, new Vector2(-0.32f, 0.12f), new Vector2(-0.2f, 0.24f), 0.045f, ((Graphic)this).color);
						AddLine(vh, rect, new Vector2(-0.32f, 0.12f), new Vector2(-0.2f, 0f), 0.045f, ((Graphic)this).color);
						AddLine(vh, rect, new Vector2(0.08f, -0.12f), new Vector2(0.32f, -0.12f), 0.055f, ((Graphic)this).color);
						AddLine(vh, rect, new Vector2(0.32f, -0.12f), new Vector2(0.2f, 0f), 0.045f, ((Graphic)this).color);
						AddLine(vh, rect, new Vector2(0.32f, -0.12f), new Vector2(0.2f, -0.24f), 0.045f, ((Graphic)this).color);
						break;
					case ToolIconKind.Sticker:
						AddPolygon(vh, rect, ((Graphic)this).color, new Vector2(-0.3f, 0.36f), new Vector2(0.28f, 0.36f), new Vector2(0.38f, 0.22f), new Vector2(0.38f, -0.34f), new Vector2(-0.3f, -0.34f));
						AddPolygon(vh, rect, new Color(0f, 0f, 0f, 0.45f), new Vector2(0.2f, 0.36f), new Vector2(0.38f, 0.18f), new Vector2(0.2f, 0.18f));
						AddFilledCircle(vh, rect, new Vector2(-0.08f, 0f), 0.13f, ((Graphic)this).color);
						AddPolygon(vh, rect, ((Graphic)this).color, new Vector2(0.12f, 0.12f), new Vector2(0.28f, -0.14f), new Vector2(0f, -0.14f));
						break;
					}
				}
			}

			private static void AddRotatedBox(VertexHelper vh, Rect rect, Vector2 center, Vector2 size, float angleDegrees, Color color)
			{
				//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)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_0040: 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_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_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: 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_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				Vector2 val = size * 0.5f;
				float num = angleDegrees * (MathF.PI / 180f);
				float cos = Mathf.Cos(num);
				float sin = Mathf.Sin(num);
				AddQuad(vh, ToRectPoint(rect, Rotate(new Vector2(0f - val.x, 0f - val.y))), ToRectPoint(rect, Rotate(new Vector2(0f - val.x, val.y))), ToRectPoint(rect, Rotate(new Vector2(val.x, val.y))), ToRectPoint(rect, Rotate(new Vector2(val.x, 0f - val.y))), color);
				Vector2 Rotate(Vector2 point)
				{
					//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_0013: 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_002e: Unknown result type (might be due to invalid IL or missing references)
					//IL_003c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0041: Unknown result type (might be due to invalid IL or missing references)
					return center + new Vector2(point.x * cos - point.y * sin, point.x * sin + point.y * cos);
				}
			}

			private static void AddBox(VertexHelper vh, Rect rect, Vector2 center, Vector2 size, Color color)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_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_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: 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_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				Vector2 val = size * 0.5f;
				AddQuad(vh, ToRectPoint(rect, center + new Vector2(0f - val.x, 0f - val.y)), ToRectPoint(rect, center + new Vector2(0f - val.x, val.y)), ToRectPoint(rect, center + new Vector2(val.x, val.y)), ToRectPoint(rect, center + new Vector2(val.x, 0f - val.y)), color);
			}

			private static void AddPolygon(VertexHelper vh, Rect rect, Color color, params Vector2[] points)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: 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_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				if (points != null && points.Length >= 3)
				{
					int currentVertCount = vh.currentVertCount;
					UIVertex simpleVert = UIVertex.simpleVert;
					simpleVert.color = Color32.op_Implicit(color);
					for (int i = 0; i < points.Length; i++)
					{
						simpleVert.position = Vector2.op_Implicit(ToRectPoint(rect, points[i]));
						vh.AddVert(simpleVert);
					}
					for (int j = 1; j < points.Length - 1; j++)
					{
						vh.AddTriangle(currentVertCount, currentVertCount + j, currentVertCount + j + 1);
					}
				}
			}

			private static void AddFilledCircle(VertexHelper vh, Rect rect, Vector2 center, float radius, Color color, int segments = 16)
			{
				//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_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//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_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_004c: 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_0069: 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_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: 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)
				int currentVertCount = vh.currentVertCount;
				UIVertex simpleVert = UIVertex.simpleVert;
				simpleVert.color = Color32.op_Implicit(color);
				simpleVert.position = Vector2.op_Implicit(ToRectPoint(rect, center));
				vh.AddVert(simpleVert);
				for (int i = 0; i <= segments; i++)
				{
					float num = (float)i / (float)segments * MathF.PI * 2f;
					Vector2 normalized = center + new Vector2(Mathf.Cos(num), Mathf.Sin(num)) * radius;
					simpleVert.position = Vector2.op_Implicit(ToRectPoint(rect, normalized));
					vh.AddVert(simpleVert);
				}
				for (int j = 1; j <= segments; j++)
				{
					vh.AddTriangle(currentVertCount, currentVertCount + j, currentVertCount + j + 1);
				}
			}

			private static void AddDrop(VertexHelper vh, Rect rect, Vector2 center, float radius, Color color)
			{
				//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_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: 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_002c: 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_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				AddFilledCircle(vh, rect, center + new Vector2(0f, (0f - radius) * 0.2f), radius * 0.72f, color, 12);
				AddPolygon(vh, rect, color, center + new Vector2(0f, radius), center + new Vector2((0f - radius) * 0.48f, (0f - radius) * 0.12f), center + new Vector2(radius * 0.48f, (0f - radius) * 0.12f));
			}

			private static void AddLine(VertexHelper vh, Rect rect, Vector2 start, Vector2 end, float thickness, Color color)
			{
				//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)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: 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_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: 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_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)
				//IL_0067: 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_006d: 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_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: 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)
				Vector2 val = ToRectPoint(rect, start);
				Vector2 val2 = ToRectPoint(rect, end);
				Vector2 val3 = val2 - val;
				if (!(((Vector2)(ref val3)).sqrMagnitude <= 0.001f))
				{
					Vector2 val4 = new Vector2(0f - val3.y, val3.x);
					Vector2 val5 = ((Vector2)(ref val4)).normalized * (Mathf.Min(((Rect)(ref rect)).width, ((Rect)(ref rect)).height) * thickness * 0.5f);
					AddQuad(vh, val - val5, val + val5, val2 + val5, val2 - val5, color);
				}
			}

			private static Vector2 ToRectPoint(Rect rect, Vector2 normalized)
			{
				//IL_0007: 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_0038: Unknown result type (might be due to invalid IL or missing references)
				return new Vector2(((Rect)(ref rect)).x + (normalized.x + 0.5f) * ((Rect)(ref rect)).width, ((Rect)(ref rect)).y + (normalized.y + 0.5f) * ((Rect)(ref rect)).height);
			}

			private static void AddQuad(VertexHelper vh, Vector2 a, Vector2 b, Vector2 c, Vector2 d, Color color)
			{
				//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_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//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_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_0037: 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_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_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_0059: 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_0066: Unknown result type (might be due to invalid IL or missing references)
				int currentVertCount = vh.currentVertCount;
				UIVertex simpleVert = UIVertex.simpleVert;
				simpleVert.color = Color32.op_Implicit(color);
				simpleVert.position = Vector2.op_Implicit(a);
				vh.AddVert(simpleVert);
				simpleVert.position = Vector2.op_Implicit(b);
				vh.AddVert(simpleVert);
				simpleVert.position = Vector2.op_Implicit(c);
				vh.AddVert(simpleVert);
				simpleVert.position = Vector2.op_Implicit(d);
				vh.AddVert(simpleVert);
				vh.AddTriangle(currentVertCount, currentVertCount + 1, currentVertCount + 2);
				vh.AddTriangle(currentVertCount + 2, currentVertCount + 3, currentVertCount);
			}
		}

		private sealed class DisabledGameplayActionState
		{
			internal InputAction Action;

			internal bool WasEnabled;

			internal string Name;
		}

		private sealed class DrawableSliderControl : Selectable, IPointerDownHandler, IEventSystemHandler, IDragHandler, IPointerUpHandler
		{
			private RectTransform _trackRect;

			private RectTransform _fillRect;

			private RectTransform _handleRect;

			private Action<float> _onValueChanged;

			private float _minValue;

			private float _maxValue = 1f;

			private float _value;

			internal float Value
			{
				get
				{
					return _value;
				}
				set
				{
					SetValue(value, notify: true);
				}
			}

			internal void Configure(RectTransform trackRect, RectTransform fillRect, RectTransform handleRect, float minValue, float maxValue, float value, Action<float> onValueChanged)
			{
				_trackRect = trackRect;
				_fillRect = fillRect;
				_handleRect = handleRect;
				_minValue = minValue;
				_maxValue = Mathf.Max(minValue + 0.0001f, maxValue);
				_onValueChanged = onValueChanged;
				SetValue(value, notify: false);
			}

			internal void SetValue(float value, bool notify)
			{
				float num = Mathf.Clamp(value, _minValue, _maxValue);
				if (Mathf.Approximately(_value, num))
				{
					UpdateVisuals();
					return;
				}
				_value = num;
				UpdateVisuals();
				if (notify)
				{
					_onValueChanged?.Invoke(_value);
				}
			}

			internal bool SetValueFromScreenPosition(Vector2 screenPosition, Camera eventCamera, bool notify)
			{
				//IL_0026: 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_004f: Unknown result type (might be due to invalid IL or missing references)
				if (!((UIBehaviour)this).IsActive() || !((Selectable)this).IsInteractable() || (Object)(object)_trackRect == (Object)null)
				{
					return false;
				}
				Vector2 val = default(Vector2);
				if (!RectTransformUtility.ScreenPointToLocalPointInRectangle(_trackRect, screenPosition, eventCamera, ref val))
				{
					return false;
				}
				Rect rect = _trackRect.rect;
				if (((Rect)(ref rect)).width <= 0.01f)
				{
					return false;
				}
				float num = Mathf.Clamp01((val.x - ((Rect)(ref rect)).xMin) / ((Rect)(ref rect)).width);
				SetValue(Mathf.Lerp(_minValue, _maxValue, num), notify);
				return true;
			}

			public override void OnPointerDown(PointerEventData eventData)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				((Selectable)this).OnPointerDown(eventData);
				SetValueFromScreenPosition(eventData.position, eventData.pressEventCamera, notify: true);
			}

			public void OnDrag(PointerEventData eventData)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				SetValueFromScreenPosition(eventData.position, eventData.pressEventCamera, notify: true);
			}

			public override void OnPointerUp(PointerEventData eventData)
			{
				((Selectable)this).OnPointerUp(eventData);
			}

			private void UpdateVisuals()
			{
				//IL_0053: 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_0083: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)_trackRect == (Object)null) && !((Object)(object)_fillRect == (Object)null) && !((Object)(object)_handleRect == (Object)null))
				{
					float num = Mathf.InverseLerp(_minValue, _maxValue, _value);
					_fillRect.anchorMin = new Vector2(0f, 0.5f);
					_fillRect.anchorMax = new Vector2(num, 0.5f);
					_fillRect.offsetMin = new Vector2(0f, -3f);
					_fillRect.offsetMax = new Vector2(0f, 3f);
					_handleRect.anchorMin = new Vector2(num, 0.5f);
					_handleRect.anchorMax = new Vector2(num, 0.5f);
					_handleRect.anchoredPosition = Vector2.zero;
					_handleRect.sizeDelta = new Vector2(14f, 14f);
				}
			}
		}

		private sealed class DrawableColorPickerControl : Selectable, IPointerDownHandler, IEventSystemHandler, IDragHandler, IPointerUpHandler
		{
			private enum DragRegion
			{
				None,
				Hue,
				SaturationValue
			}

			private RectTransform _hueRect;

			private RectTransform _svRect;

			private RectTransform _hueHandle;

			private RectTransform _svHandle;

			private RawImage _hueImage;

			private RawImage _svImage;

			private Image _swatch;

			private Texture2D _hueTexture;

			private Texture2D _svTexture;

			private Action<Color> _onColorChanged;

			private float _hue;

			private float _saturation = 1f;

			private float _value = 1f;

			private DragRegion _dragRegion;

			private float _lastDiagnosticsTime;

			private string _lastDiagnosticsKey = string.Empty;

			internal void Configure(RectTransform hueRect, RectTransform svRect, RectTransform hueHandle, RectTransform svHandle, RawImage hueImage, RawImage svImage, Image swatch, Color initialColor, Action<Color> onColorChanged)
			{
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				_hueRect = hueRect;
				_svRect = svRect;
				_hueHandle = hueHandle;
				_svHandle = svHandle;
				_hueImage = hueImage;
				_svImage = svImage;
				_swatch = swatch;
				_onColorChanged = onColorChanged;
				BuildHueTexture();
				SetColor(initialColor, notify: false);
			}

			internal void SetColor(Color color, bool notify)
			{
				//IL_0000: 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)
				Color.RGBToHSV(color, ref _hue, ref _saturation, ref _value);
				UpdateSaturationValueTexture();
				UpdateVisuals();
				if (notify)
				{
					_onColorChanged?.Invoke(CurrentColor());
				}
			}

			internal bool SetValueFromScreenPosition(Vector2 screenPosition, Camera eventCamera, bool notify)
			{
				//IL_001c: 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_00a7: 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_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: 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_00f4: 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)
				if (!((UIBehaviour)this).IsActive() || !((Selectable)this).IsInteractable())
				{
					return false;
				}
				if (_dragRegion == DragRegion.None)
				{
					_dragRegion = ResolveRegion(screenPosition, eventCamera);
				}
				if (_dragRegion == DragRegion.Hue)
				{
					Vector2 localPoint = default(Vector2);
					if (!RectTransformUtility.ScreenPointToLocalPointInRectangle(_hueRect, screenPosition, eventCamera, ref localPoint))
					{
						return false;
					}
					if (!TryGetHueFromLocalPoint(localPoint, _hueRect.rect, out var hue))
					{
						return false;
					}
					_hue = hue;
					UpdateSaturationValueTexture();
					UpdateVisuals();
					LogPickerDiagnostics("Hue", screenPosition, localPoint);
					if (notify)
					{
						_onColorChanged?.Invoke(CurrentColor());
					}
					return true;
				}
				if (_dragRegion == DragRegion.SaturationValue)
				{
					Vector2 localPoint2 = default(Vector2);
					if (!RectTransformUtility.ScreenPointToLocalPointInRectangle(_svRect, screenPosition, eventCamera, ref localPoint2))
					{
						return false;
					}
					GetSaturationValueFromLocalPoint(localPoint2, _svRect.rect, out _saturation, out _value);
					UpdateVisuals();
					LogPickerDiagnostics("SaturationValue", screenPosition, localPoint2);
					if (notify)
					{
						_onColorChanged?.Invoke(CurrentColor());
					}
					return true;
				}
				return false;
			}

			public override void OnPointerDown(PointerEventData eventData)
			{
				//IL_000a: 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)
				((Selectable)this).OnPointerDown(eventData);
				_dragRegion = ResolveRegion(eventData.position, eventData.pressEventCamera);
				SetValueFromScreenPosition(eventData.position, eventData.pressEventCamera, notify: true);
			}

			public void OnDrag(PointerEventData eventData)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				SetValueFromScreenPosition(eventData.position, eventData.pressEventCamera, notify: true);
			}

			public override void OnPointerUp(PointerEventData eventData)
			{
				((Selectable)this).OnPointerUp(eventData);
				_dragRegion = DragRegion.None;
			}

			internal void EndVirtualDrag()
			{
				_dragRegion = DragRegion.None;
			}

			private DragRegion ResolveRegion(Vector2 screenPosition, Camera eventCamera)
			{
				//IL_0014: 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_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_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_svRect != (Object)null && RectTransformUtility.RectangleContainsScreenPoint(_svRect, screenPosition, eventCamera))
				{
					return DragRegion.SaturationValue;
				}
				Vector2 val = default(Vector2);
				if ((Object)(object)_hueRect != (Object)null && RectTransformUtility.ScreenPointToLocalPointInRectangle(_hueRect, screenPosition, eventCamera, ref val))
				{
					Rect rect = _hueRect.rect;
					float num = Mathf.Min(((Rect)(ref rect)).width, ((Rect)(ref rect)).height) * 0.5f;
					float num2 = Vector2.Distance(val, ((Rect)(ref rect)).center);
					if (num2 >= num * 0.68f && num2 <= num)
					{
						return DragRegion.Hue;
					}
				}
				return DragRegion.None;
			}

			private Color CurrentColor()
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				Color result = Color.HSVToRGB(_hue, _saturation, _value);
				result.a = 1f;
				return result;
			}

			private void UpdateVisuals()
			{
				//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_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				Color color = CurrentColor();
				if ((Object)(object)_swatch != (Object)null)
				{
					((Graphic)_swatch).color = color;
				}
				if ((Object)(object)_hueHandle != (Object)null && (Object)(object)_hueRect != (Object)null)
				{
					Rect rect = _hueRect.rect;
					_hueHandle.anchoredPosition = GetHueHandlePosition(rect);
				}
				if ((Object)(object)_svHandle != (Object)null && (Object)(object)_svRect != (Object)null)
				{
					Rect rect2 = _svRect.rect;
					_svHandle.anchoredPosition = GetSaturationValueHandlePosition(rect2);
				}
			}

			private bool TryGetHueFromLocalPoint(Vector2 localPoint, Rect rect, out float hue)
			{
				//IL_0000: 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)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				Vector2 val = localPoint - ((Rect)(ref rect)).center;
				if (((Vector2)(ref val)).sqrMagnitude < 1f)
				{
					hue = _hue;
					return false;
				}
				hue = Mathf.Repeat(Mathf.Atan2(val.y, val.x) / (MathF.PI * 2f), 1f);
				return true;
			}

			private static void GetSaturationValueFromLocalPoint(Vector2 localPoint, Rect rect, out float saturation, out float value)
			{
				//IL_0016: 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)
				saturation = ((((Rect)(ref rect)).width > 0.01f) ? Mathf.Clamp01((localPoint.x - ((Rect)(ref rect)).xMin) / ((Rect)(ref rect)).width) : 0f);
				value = ((((Rect)(ref rect)).height > 0.01f) ? Mathf.Clamp01((localPoint.y - ((Rect)(ref rect)).yMin) / ((Rect)(ref rect)).height) : 0f);
			}

			private Vector2 GetHueHandlePosition(Rect rect)
			{
				//IL_0039: 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)
				float num = Mathf.Min(((Rect)(ref rect)).width, ((Rect)(ref rect)).height) * 0.43f;
				float num2 = _hue * MathF.PI * 2f;
				return new Vector2(Mathf.Cos(num2), Mathf.Sin(num2)) * num;
			}

			private Vector2 GetSaturationValueHandlePosition(Rect rect)
			{
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				return new Vector2((_saturation - 0.5f) * ((Rect)(ref rect)).width, (_value - 0.5f) * ((Rect)(ref rect)).height);
			}

			private void LogPickerDiagnostics(string region, Vector2 screenPosition, Vector2 localPoint)
			{
				//IL_002f: 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_0034: 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_0043: 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_00b2: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_015f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0168: Unknown result type (might be due to invalid IL or missing references)
				//IL_0171: Unknown result type (might be due to invalid IL or missing references)
				//IL_017a: Unknown result type (might be due to invalid IL or missing references)
				if (!(Time.unscaledTime - _lastDiagnosticsTime < 0.25f))
				{
					Vector2 val = (((Object)(object)_hueHandle != (Object)null) ? _hueHandle.anchoredPosition : Vector2.zero);
					Vector2 val2 = (((Object)(object)_svHandle != (Object)null) ? _svHandle.anchoredPosition : Vector2.zero);
					string text = $"{region}:{Mathf.RoundToInt(_hue * 360f)}:{Mathf.RoundToInt(_saturation * 100f)}:{Mathf.RoundToInt(_value * 100f)}:{Mathf.RoundToInt(val.x)}:{Mathf.RoundToInt(val.y)}:{Mathf.RoundToInt(val2.x)}:{Mathf.RoundToInt(val2.y)}";
					if (!string.Equals(text, _lastDiagnosticsKey, StringComparison.Ordinal))
					{
						_lastDiagnosticsTime = Time.unscaledTime;
						_lastDiagnosticsKey = text;
						DrawableSuitsDiagnostics.Info($"ColorPickerInput region={region}; hue={_hue:0.###}; saturation={_saturation:0.###}; value={_value:0.###}; screen={screenPosition}; local={localPoint}; hueHandle={val}; svHandle={val2}");
					}
				}
			}

			private void BuildHueTexture()
			{
				//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_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Expected O, but got Unknown
				//IL_0172: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0117: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_hueImage == (Object)null)
				{
					return;
				}
				_hueTexture = new Texture2D(128, 128, (TextureFormat)4, false)
				{
					name = "DrawableSuitsHueRing",
					wrapMode = (TextureWrapMode)1,
					filterMode = (FilterMode)1
				};
				Vector2 val = default(Vector2);
				((Vector2)(ref val))..ctor((float)(((Texture)_hueTexture).width - 1) * 0.5f, (float)(((Texture)_hueTexture).height - 1) * 0.5f);
				float num = (float)((Texture)_hueTexture).width * 0.49f;
				float num2 = (float)((Texture)_hueTexture).width * 0.34f;
				for (int i = 0; i < ((Texture)_hueTexture).height; i++)
				{
					for (int j = 0; j < ((Texture)_hueTexture).width; j++)
					{
						Vector2 val2 = new Vector2((float)j, (float)i) - val;
						float magnitude = ((Vector2)(ref val2)).magnitude;
						if (magnitude < num2 || magnitude > num)
						{
							_hueTexture.SetPixel(j, i, Color.clear);
							continue;
						}
						float num3 = Mathf.Repeat(Mathf.Atan2(val2.y, val2.x) / (MathF.PI * 2f), 1f);
						_hueTexture.SetPixel(j, i, Color.HSVToRGB(num3, 1f, 1f));
					}
				}
				_hueTexture.Apply(false, true);
				_hueImage.texture = (Texture)(object)_hueTexture;
				((Graphic)_hueImage).color = Color.white;
				((Graphic)_hueImage).raycastTarget = true;
			}

			private void UpdateSaturationValueTexture()
			{
				//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_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Expected O, but got Unknown
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_svImage == (Object)null)
				{
					return;
				}
				if ((Object)(object)_svTexture == (Object)null)
				{
					_svTexture = new Texture2D(64, 64, (TextureFormat)4, false)
					{
						name = "DrawableSuitsSaturationValue",
						wrapMode = (TextureWrapMode)1,
						filterMode = (FilterMode)1
					};
					_svImage.texture = (Texture)(object)_svTexture;
					((Graphic)_svImage).raycastTarget = true;
				}
				for (int i = 0; i < ((Texture)_svTexture).height; i++)
				{
					float num = (float)i / (float)(((Texture)_svTexture).height - 1);
					for (int j = 0; j < ((Texture)_svTexture).width; j++)
					{
						float num2 = (float)j / (float)(((Texture)_svTexture).width - 1);
						_svTexture.SetPixel(j, i, Color.HSVToRGB(_hue, num2, num));
					}
				}
				_svTexture.Apply(false, false);
			}

			protected override void OnDestroy()
			{
				((UIBehaviour)this).OnDestroy();
				if ((Object)(object)_hueTexture != (Object)null)
				{
					Object.Destroy((Object)(object)_hueTexture);
					_hueTexture = null;
				}
				if ((Object)(object)_svTexture != (Object)null)
				{
					Object.Destroy((Object)(object)_svTexture);
					_svTexture = null;
				}
			}
		}

		private sealed class TextStampRenderer
		{
			private const int RenderFontSize = 128;

			private const int RenderHeight = 256;

			private const int RenderPadding = 64;

			private const int TrimPadding = 8;

			private GameObject _root;

			private Camera _camera;

			private Canvas _canvas;

			private RectTransform _canvasRect;

			private Text _text;

			private RectTransform _textRect;

			private RenderTexture _renderTexture;

			private Texture2D _readbackTexture;

			private Texture2D _texture;

			private string _cachedKey = string.Empty;

			internal Texture2D GetOrRender(string text, out string key, out string failureReason)
			{
				//IL_010f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
				failureReason = string.Empty;
				string text2 = NormalizeTextStampValue(text);
				key = $"{text2}|Arial|{128}|AlphaMaskV2";
				if (string.IsNullOrWhiteSpace(text2))
				{
					failureReason = "empty text";
					return null;
				}
				if ((Object)(object)_texture != (Object)null && string.Equals(key, _cachedKey, StringComparison.Ordinal))
				{
					return _texture;
				}
				try
				{
					Font builtinResource = Resources.GetBuiltinResource<Font>("Arial.ttf");
					if ((Object)(object)builtinResource == (Object)null)
					{
						failureReason = "built-in Arial font unavailable";
						return null;
					}
					builtinResource.RequestCharactersInTexture(text2, 128, (FontStyle)0);
					int num = CalculateTextureWidth(builtinResource, text2, 128);
					EnsureObjects(num, 256);
					_text.font = builtinResource;
					_text.text = text2;
					_text.fontSize = 128;
					_text.fontStyle = (FontStyle)0;
					_text.alignment = (TextAnchor)4;
					_text.horizontalOverflow = (HorizontalWrapMode)1;
					_text.verticalOverflow = (VerticalWrapMode)1;
					_text.supportRichText = false;
					((Graphic)_text).color = Color.white;
					_canvasRect.sizeDelta = new Vector2((float)num, 256f);
					_textRect.sizeDelta = new Vector2((float)num - 128f, 256f);
					_camera.orthographicSize = 128f;
					_camera.aspect = (float)num / 256f;
					_camera.targetTexture = _renderTexture;
					RenderTexture active = RenderTexture.active;
					bool activeSelf = _root.activeSelf;
					try
					{
						_root.SetActive(true);
						Canvas.ForceUpdateCanvases();
						RenderTexture.active = _renderTexture;
						GL.Clear(true, true, new Color(0f, 0f, 0f, 0f));
						_camera.Render();
						_readbackTexture.ReadPixels(new Rect(0f, 0f, (float)num, 256f), 0, 0, false);
						_readbackTexture.Apply(false, false);
					}
					finally
					{
						RenderTexture.active = active;
						_root.SetActive(activeSelf);
					}
					if (!TryBuildTrimmedAlphaMask(_readbackTexture, out var trimmedTexture, out var rawBounds, out var finalSize, out var visiblePixels))
					{
						failureReason = "rendered text texture was empty";
						DrawableSuitsDiagnostics.Warn($"TextStampSkipped: reason={failureReason}; textLength={text2.Length}; rawTexture={num}x{256}; alphaMode=luminance");
						return null;
					}
					if ((Object)(object)_texture != (Object)null && _texture != trimmedTexture)
					{
						Object.Destroy((Object)(object)_texture);
					}
					_texture = trimmedTexture;
					_cachedKey = key;
					DrawableSuitsDiagnostics.Info($"TextStampRendered: textLength={text2.Length}; rawTexture={num}x{256}; glyphBounds={rawBounds}; finalTexture={((Vector2Int)(ref finalSize)).x}x{((Vector2Int)(ref finalSize)).y}; visiblePixels={visiblePixels}; alphaMode=luminance");
					return _texture;
				}
				catch (Exception ex)
				{
					failureReason = ex.Message;
					DrawableSuitsDiagnostics.Exception($"TextStampSkipped: render exception. textLength={text2.Length}", ex);
					return null;
				}
			}

			internal void Destroy()
			{
				if ((Object)(object)_texture != (Object)null)
				{
					Object.Destroy((Object)(object)_texture);
					_texture = null;
				}
				if ((Object)(object)_renderTexture != (Object)null)
				{
					_renderTexture.Release();
					Object.Destroy((Object)(object)_renderTexture);
					_renderTexture = null;
				}
				if ((Object)(object)_readbackTexture != (Object)null)
				{
					Object.Destroy((Object)(object)_readbackTexture);
					_readbackTexture = null;
				}
				if ((Object)(object)_root != (Object)null)
				{
					Object.Destroy((Object)(object)_root);
					_root = null;
				}
				_cachedKey = string.Empty;
			}

			private void EnsureObjects(int rawWidth, int rawHeight)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Expected O, but got Unknown
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Expected O, but got Unknown
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0163: Unknown result type (might be due to invalid IL or missing references)
				//IL_0169: Expected O, but got Unknown
				//IL_018e: Unknown result type (might be due to invalid IL or missing references)
				//IL_019e: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0238: Unknown result type (might be due to invalid IL or missing references)
				//IL_023e: Expected O, but got Unknown
				//IL_0274: Unknown result type (might be due to invalid IL or missing references)
				//IL_028e: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0345: Unknown result type (might be due to invalid IL or missing references)
				//IL_034a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0355: Unknown result type (might be due to invalid IL or missing references)
				//IL_035d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0364: Unknown result type (might be due to invalid IL or missing references)
				//IL_0370: Expected O, but got Unknown
				//IL_03c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_03d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_03e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ef: Expected O, but got Unknown
				if ((Object)(object)_root == (Object)null)
				{
					_root = new GameObject("DrawableSuitsTextStampRenderer");
					((Object)_root).hideFlags = (HideFlags)61;
					_root.transform.position = new Vector3(10000f, 10000f, 10000f);
					GameObject val = new GameObject("DrawableSuitsTextStampCamera", new Type[1] { typeof(Camera) });
					((Object)val).hideFlags = (HideFlags)61;
					val.transform.SetParent(_root.transform, false);
					val.transform.localPosition = new Vector3(0f, 0f, -10f);
					val.transform.localRotation = Quaternion.identity;
					_camera = val.GetComponent<Camera>();
					((Behaviour)_camera).enabled = false;
					_camera.clearFlags = (CameraClearFlags)2;
					_camera.backgroundColor = new Color(0f, 0f, 0f, 0f);
					_camera.orthographic = true;
					_camera.nearClipPlane = 0.01f;
					_camera.farClipPlane = 50f;
					_camera.cullingMask = 4;
					GameObject val2 = new GameObject("DrawableSuitsTextStampCanvas", new Type[2]
					{
						typeof(RectTransform),
						typeof(Canvas)
					});
					((Object)val2).hideFlags = (HideFlags)61;
					val2.transform.SetParent(_root.transform, false);
					val2.transform.localPosition = Vector3.zero;
					val2.transform.localRotation = Quaternion.identity;
					val2.transform.localScale = Vector3.one;
					_canvasRect = val2.GetComponent<RectTransform>();
					_canvasRect.pivot = new Vector2(0.5f, 0.5f);
					_canvas = val2.GetComponent<Canvas>();
					_canvas.renderMode = (RenderMode)2;
					_canvas.worldCamera = _camera;
					_canvas.pixelPerfect = true;
					GameObject val3 = new GameObject("DrawableSuitsTextStampText", new Type[2]
					{
						typeof(RectTransform),
						typeof(Text)
					});
					((Object)val3).hideFlags = (HideFlags)61;
					val3.transform.SetParent(val2.transform, false);
					_textRect = val3.GetComponent<RectTransform>();
					_textRect.anchorMin = new Vector2(0.5f, 0.5f);
					_textRect.anchorMax = new Vector2(0.5f, 0.5f);
					_textRect.pivot = new Vector2(0.5f, 0.5f);
					_textRect.anchoredPosition = Vector2.zero;
					_text = val3.GetComponent<Text>();
					((Graphic)_text).raycastTarget = false;
					SetLayerRecursively(_root, 2);
					_root.SetActive(false);
				}
				if ((Object)(object)_renderTexture == (Object)null || ((Texture)_renderTexture).width != rawWidth || ((Texture)_renderTexture).height != rawHeight)
				{
					if ((Object)(object)_renderTexture != (Object)null)
					{
						_renderTexture.Release();
						Object.Destroy((Object)(object)_renderTexture);
					}
					_renderTexture = new RenderTexture(rawWidth, rawHeight, 0, (RenderTextureFormat)0)
					{
						name = "DrawableSuitsTextStampRenderTexture",
						hideFlags = (HideFlags)61,
						filterMode = (FilterMode)1,
						wrapMode = (TextureWrapMode)1
					};
					_renderTexture.Create();
				}
				if ((Object)(object)_readbackTexture == (Object)null || ((Texture)_readbackTexture).width != rawWidth || ((Texture)_readbackTexture).height != rawHeight)
				{
					if ((Object)(object)_readbackTexture != (Object)null)
					{
						Object.Destroy((Object)(object)_readbackTexture);
					}
					_readbackTexture = new Texture2D(rawWidth, rawHeight, (TextureFormat)4, false)
					{
						name = "DrawableSuitsTextStampReadback",
						hideFlags = (HideFlags)61,
						filterMode = (FilterMode)1,
						wrapMode = (TextureWrapMode)1
					};
					_cachedKey = string.Empty;
				}
			}

			private static int CalculateTextureWidth(Font font, string text, int fontSize)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: 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_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: 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)
				TextGenerationSettings val = new TextGenerationSettings
				{
					font = font,
					fontSize = fontSize,
					fontStyle = (FontStyle)0,
					color = Color.white,
					textAnchor = (TextAnchor)4,
					horizontalOverflow = (HorizontalWrapMode)1,
					verticalOverflow = (VerticalWrapMode)1,
					richText = false,
					lineSpacing = 1f,
					scaleFactor = 1f,
					generationExtents = new Vector2(2048f, 256f),
					pivot = new Vector2(0.5f, 0.5f),
					updateBounds = true
				};
				float preferredWidth = new TextGenerator().GetPreferredWidth(text, val);
				int num = Mathf.Clamp(SystemInfo.maxTextureSize, 2048, 8192);
				return Mathf.Clamp(Mathf.CeilToInt(preferredWidth) + 128, 256, num);
			}

			private static bool TryBuildTrimmedAlphaMask(Texture2D source, out Texture2D trimmedTexture, out RectInt rawBounds, out Vector2Int finalSize, out int visiblePixels)
			{
				//IL_0004: 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_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d3: Expected O, but got Unknown
				//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0200: Unknown result type (might be due to invalid IL or missing references)
				//IL_0140: Unknown result type (might be due to invalid IL or missing references)
				//IL_0180: Unknown result type (might be due to invalid IL or missing references)
				//IL_0169: Unknown result type (might be due to invalid IL or missing references)
				//IL_0185: Unknown result type (might be due to invalid IL or missing references)
				trimmedTexture = null;
				rawBounds = default(RectInt);
				finalSize = default(Vector2Int);
				visiblePixels = 0;
				if ((Object)(object)source == (Object)null)
				{
					return false;
				}
				Color32[] pixels = source.GetPixels32();
				int num = ((Texture)source).width;
				int num2 = ((Texture)source).height;
				int num3 = -1;
				int num4 = -1;
				for (int i = 0; i < ((Texture)source).height; i++)
				{
					int num5 = i * ((Texture)source).width;
					for (int j = 0; j < ((Texture)source).width; j++)
					{
						if (AlphaFromLuminance(pixels[num5 + j]) > 4)
						{
							num = Mathf.Min(num, j);
							num2 = Mathf.Min(num2, i);
							num3 = Mathf.Max(num3, j);
							num4 = Mathf.Max(num4, i);
							visiblePixels++;
						}
					}
				}
				if (num3 < num || num4 < num2)
				{
					return false;
				}
				num = Mathf.Max(0, num - 8);
				num2 = Mathf.Max(0, num2 - 8);
				num3 = Mathf.Min(((Texture)source).width - 1, num3 + 8);
				num4 = Mathf.Min(((Texture)source).height - 1, num4 + 8);
				int num6 = Mathf.Max(1, num3 - num + 1);
				int num7 = Mathf.Max(1, num4 - num2 + 1);
				Color32[] array = (Color32[])(object)new Color32[num6 * num7];
				for (int k = 0; k < num7; k++)
				{
					int num8 = (num2 + k) * ((Texture)source).width;
					int num9 = k * num6;
					for (int l = 0; l < num6; l++)
					{
						byte b = AlphaFromLuminance(pixels[num8 + num + l]);
						array[num9 + l] = ((b <= 1) ? new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, (byte)0) : new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, b));
					}
				}
				trimmedTexture = new Texture2D(num6, num7, (TextureFormat)4, false)
				{
					name = "DrawableSuitsTextStampTexture",
					hideFlags = (HideFlags)61,
					filterMode = (FilterMode)1,
					wrapMode = (TextureWrapMode)1
				};
				trimmedTexture.SetPixels32(array);
				trimmedTexture.Apply(false, false);
				rawBounds = new RectInt(num, num2, num6, num7);
				finalSize = new Vector2Int(num6, num7);
				return true;
			}

			private static byte AlphaFromLuminance(Color32 pixel)
			{
				//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)
				int num = Mathf.Max((int)pixel.r, Mathf.Max((int)pixel.g, (int)pixel.b));
				if (num > 1)
				{
					return (byte)num;
				}
				return 0;
			}

			private static void SetLayerRecursively(GameObject gameObject, int layer)
			{
				if (!((Object)(object)gameObject == (Object)null))
				{
					gameObject.layer = layer;
					for (int i = 0; i < gameObject.transform.childCount; i++)
					{
						SetLayerRecursively(((Component)gameObject.transform.GetChild(i)).gameObject, layer);
					}
				}
			}
		}

		private struct UvPanelPlacementFrame
		{
			public Vector2 RightAxis;

			public Vector2 UpAxis;

			public float Width;

			public float Height;

			public int HalfExtentX;

			public int HalfExtentY;

			public float EffectiveRotation;
		}

		private sealed class DrawableCanvasCursorGraphic : Graphic
		{
			private const int CircleSegments = 64;

			private CursorVisualMode _mode;

			private Color _cursorColor = Color.white;

			private float _diameter = 15f;

			public CursorVisualMode Mode => _mode;

			public float Diameter => _diameter;

			public void SetVisual(CursorVisualMode mode, Color cursorColor, float diameter)
			{
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: 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_0074: 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)
				diameter = Mathf.Max(1f, diameter);
				if (_mode != mode || !(Mathf.Abs(_diameter - diameter) < 0.05f) || !(Mathf.Abs(_cursorColor.r - cursorColor.r) < 0.003f) || !(Mathf.Abs(_cursorColor.g - cursorColor.g) < 0.003f) || !(Mathf.Abs(_cursorColor.b - cursorColor.b) < 0.003f) || !(Mathf.Abs(_cursorColor.a - cursorColor.a) < 0.003f))
				{
					_mode = mode;
					_cursorColor = cursorColor;
					_diameter = diameter;
					((Graphic)this).SetVerticesDirty();
				}
			}

			protected override void OnPopulateMesh(VertexHelper vh)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: 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_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_020f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0193: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
				vh.Clear();
				Rect rect = ((Graphic)this).rectTransform.rect;
				Vector2 center = ((Rect)(ref rect)).center;
				if (_mode == CursorVisualMode.BrushRing)
				{
					float num = Mathf.Min(((Rect)(ref rect)).width, ((Rect)(ref rect)).height) * 0.5f - 5f;
					num = Mathf.Max(5f, Mathf.Min(num, _diameter * 0.5f));
					float thickness = Mathf.Clamp(_diameter * 0.14f, 4f, 10f);
					float thickness2 = Mathf.Clamp(_diameter * 0.07f, 2f, 6f);
					AddRing(vh, center, num, thickness, new Color32((byte)0, (byte)0, (byte)0, (byte)245));
					AddRing(vh, center, num, thickness2, ToColor32(_cursorColor));
				}
				else if (_mode == CursorVisualMode.BrushSquare || _mode == CursorVisualMode.BrushPixel)
				{
					float size = ((_mode == CursorVisualMode.BrushPixel) ? (Mathf.Min(((Rect)(ref rect)).width, ((Rect)(ref rect)).height) * 0.72f) : Mathf.Max(6f, Mathf.Min(Mathf.Min(((Rect)(ref rect)).width, ((Rect)(ref rect)).height) - 10f, _diameter)));
					float thickness3 = ((_mode == CursorVisualMode.BrushPixel) ? 5f : Mathf.Clamp(_diameter * 0.13f, 4f, 10f));
					float thickness4 = ((_mode == CursorVisualMode.BrushPixel) ? 2f : Mathf.Clamp(_diameter * 0.065f, 2f, 6f));
					AddSquareRing(vh, center, size, thickness3, new Color32((byte)0, (byte)0, (byte)0, (byte)245));
					AddSquareRing(vh, center, size, thickness4, ToColor32(_cursorColor));
				}
				else
				{
					float num2 = Mathf.Min(((Rect)(ref rect)).width, ((Rect)(ref rect)).height) * 0.5f;
					float radius = num2 * 0.58f;
					AddDisc(vh, center, num2, new Color32((byte)0, (byte)0, (byte)0, (byte)235));
					AddDisc(vh, center, radius, new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue));
				}
			}

			private static void AddDisc(VertexHelper vh, Vector2 center, float radius, Color32 color)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				int currentVertCount = vh.currentVertCount;
				AddVertex(vh, center, color);
				for (int i = 0; i <= 64; i++)
				{
					float num = (float)i / 64f * MathF.PI * 2f;
					AddVertex(vh, center + new Vector2(Mathf.Cos(num), Mathf.Sin(num)) * radius, color);
				}
				for (int j = 0; j < 64; j++)
				{
					vh.AddTriangle(currentVertCount, currentVertCount + j + 1, currentVertCount + j + 2);
				}
			}

			private static void AddRing(VertexHelper vh, Vector2 center, float radius, float thickness, Color32 color)
			{
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_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)
				float num = Mathf.Max(0f, radius - thickness * 0.5f);
				float num2 = radius + thickness * 0.5f;
				int currentVertCount = vh.currentVertCount;
				Vector2 val = default(Vector2);
				for (int i = 0; i <= 64; i++)
				{
					float num3 = (float)i / 64f * MathF.PI * 2f;
					((Vector2)(ref val))..ctor(Mathf.Cos(num3), Mathf.Sin(num3));
					AddVertex(vh, center + val * num2, color);
					AddVertex(vh, center + val * num, color);
				}
				for (int j = 0; j < 64; j++)
				{
					int num4 = currentVertCount + j * 2;
					int num5 = num4 + 1;
					int num6 = num4 + 2;
					int num7 = num4 + 3;
					vh.AddTriangle(num4, num6, num7);
					vh.AddTriangle(num4, num7, num5);
				}
			}

			private static void AddSquareRing(VertexHelper vh, Vector2 center, float size, float thickness, Color32 color)
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: 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_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: 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_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: 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_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00df: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				float num = Mathf.Max(1f, size * 0.5f + thickness * 0.5f);
				float num2 = Mathf.Max(0f, size * 0.5f - thickness * 0.5f);
				int currentVertCount = vh.currentVertCount;
				AddVertex(vh, center + new Vector2(0f - num, 0f - num), color);
				AddVertex(vh, center + new Vector2(num, 0f - num), color);
				AddVertex(vh, center + new Vector2(num, num), color);
				AddVertex(vh, center + new Vector2(0f - num, num), color);
				AddVertex(vh, center + new Vector2(0f - num2, 0f - num2), color);
				AddVertex(vh, center + new Vector2(num2, 0f - num2), color);
				AddVertex(vh, center + new Vector2(num2, num2), color);
				AddVertex(vh, center + new Vector2(0f - num2, num2), color);
				vh.AddTriangle(currentVertCount, currentVertCount + 1, currentVertCount + 5);
				vh.AddTriangle(currentVertCount, currentVertCount + 5, currentVertCount + 4);
				vh.AddTriangle(currentVertCount + 1, currentVertCount + 2, currentVertCount + 6);
				vh.AddTriangle(currentVertCount + 1, currentVertCount + 6, currentVertCount + 5);
				vh.AddTriangle(currentVertCount + 2, currentVertCount + 3, currentVertCount + 7);
				vh.AddTriangle(currentVertCount + 2, currentVertCount + 7, currentVertCount + 6);
				vh.AddTriangle(currentVertCount + 3, currentVertCount, currentVertCount + 4);
				vh.AddTriangle(currentVertCount + 3, currentVertCount + 4, currentVertCount + 7);
			}

			private static void AddVertex(VertexHelper vh, Vector2 position, Color32 color)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				UIVertex simpleVert = UIVertex.simpleVert;
				simpleVert.color = color;
				simpleVert.position = Vector2.op_Implicit(position);
				vh.AddVert(simpleVert);
			}

			private static Color32 ToColor32(Color color)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: 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_005c: Unknown result type (might be due to invalid IL or missing references)
				return new Color32((byte)Mathf.RoundToInt(Mathf.Clamp01(color.r) * 255f), (byte)Mathf.RoundToInt(Mathf.Clamp01(color.g) * 255f), (byte)Mathf.RoundToInt(Mathf.Clamp01(color.b) * 255f), (byte)Mathf.RoundToInt(Mathf.Clamp01(color.a) * 255f));
			}
		}

		private const int EditorCanvasSortingOrder = 32760;

		private const int MaxRecentColors = 12;

		private const float DotCursorRootSize = 17f;

		private const float DotCursorBackSize = 15f;

		private const float DotCursorFrontSize = 9f;

		private const float WorldPlacementPreviewMinInterval = 0.05f;

		private const float WorldPlacementPreviewIdleDelay = 0.15f;

		private const float WorldPlacementPreviewMoveThresholdPixels = 2f;

		private const int PlacementEditPreviewMaxTextureSize = 160;

		private const float SliderHandleVisualSize = 14f;

		private const float UvPanelMinZoom = 1f;

		private const float UvPanelMaxZoom = 8f;

		private const float UvPanelWheelZoomFactor = 1.18f;

		private const float UvPanelDpadZoomFactorPerSecond = 1.9f;

		private const float UvPanelGamepadPanDeadzone = 0.2f;

		private const float UvPanelGamepadPanSpeed = 1.8f;

		private const float PlacementRotationShortcutStepDegrees = 5f;

		private static readonly Color TerminalPanelColor = new Color(0.018f, 0.022f, 0.024f, 0.88f);

		private static readonly Color TerminalDialogColor = new Color(0.022f, 0.024f, 0.026f, 0.98f);

		private static readonly Color TerminalCardColor = new Color(0.02f, 0.022f, 0.026f, 0.88f);

		private static readonly Color TerminalInputColor = new Color(0.09f, 0.012f, 0.012f, 0.9f);

		private static readonly Color TerminalButtonColor = new Color(0.105f, 0.012f, 0.012f, 0.94f);

		private static readonly Color TerminalButtonPressedColor = new Color(0.45f, 0.035f, 0.025f, 1f);

		private static readonly Color TerminalAccentColor = new Color(0.72f, 0.055f, 0.035f, 1f);

		private static readonly Color TerminalAccentHotColor = new Color(1f, 0.22f, 0.12f, 1f);

		private static readonly Color TerminalTextColor = new Color(0.94f, 0.88f, 0.78f, 1f);

		private static readonly Color TerminalMutedTextColor = new Color(0.72f, 0.66f, 0.58f, 1f);

		private static readonly Color TerminalStatusColor = new Color(1f, 0.42f, 0.18f, 1f);

		private static readonly Color TerminalDiagnosticsColor = new Color(0.86f, 0.75f, 0.64f, 1f);

		private static readonly Color TerminalSliderTrackColor = new Color(0.13f, 0.015f, 0.015f, 1f);

		private static readonly Color TerminalSliderFillColor = new Color(0.82f, 0.06f, 0.035f, 1f);

		private static readonly Color TerminalOutlineColor = new Color(0.42f, 0.025f, 0.02f, 0.9f);

		private static readonly Dictionary<ToolIconKind, Texture2D> ToolIconTextureCache = new Dictionary<ToolIconKind, Texture2D>();

		private static Texture2D SliderHandleDotTexture;

		private static Sprite SliderHandleDotSprite;

		private static readonly Vector2[] StickerTriangleVertices = (Vector2[])(object)new Vector2[3]
		{
			new Vector2(0f, 0.9f),
			new Vector2(-0.9f, -0.78f),
			new Vector2(0.9f, -0.78f)
		};

		private static readonly Vector2[] StickerArrowVertices = (Vector2[])(object)new Vector2[7]
		{
			new Vector2(-0.9f, -0.28f),
			new Vector2(0.12f, -0.28f),
			new Vector2(0.12f, -0.62f),
			new Vector2(0.9f, 0f),
			new Vector2(0.12f, 0.62f),
			new Vector2(0.12f, 0.28f),
			new Vector2(-0.9f, 0.28f)
		};

		private static readonly Vector2[] StickerLightningVertices = (Vector2[])(object)new Vector2[7]
		{
			new Vector2(-0.25f, 0.92f),
			new Vector2(0.55f, 0.92f),
			new Vector2(0.1f, 0.14f),
			new Vector2(0.64f, 0.14f),
			new Vector2(-0.32f, -0.96f),
			new Vector2(-0.02f, -0.24f),
			new Vector2(-0.58f, -0.24f)
		};

		private static readonly Vector2[] StickerShieldVertices = (Vector2[])(object)new Vector2[5]
		{
			new Vector2(-0.72f, 0.7f),
			new Vector2(0.72f, 0.7f),
			new Vector2(0.62f, -0.18f),
			new Vector2(0f, -0.92f),
			new Vector2(-0.62f, -0.18f)
		};

		private static readonly PlacementFilter[] PlacementFilterRows = new PlacementFilter[7]
		{
			PlacementFilter.Grayscale,
			PlacementFilter.Sepia,
			PlacementFilter.Invert,
			PlacementFilter.Brightness,
			PlacementFilter.Contrast,
			PlacementFilter.Saturation,
			PlacementFilter.HueShift
		};

		private readonly Stack<UndoHistoryEntry> _undo = new Stack<UndoHistoryEntry>();

		private readonly Stack<UndoHistoryEntry> _redo = new Stack<UndoHistoryEntry>();

		private readonly List<string> _designFiles = new List<string>();

		private readonly List<string> _decalFiles = new List<string>();

		private readonly List<string> _recentColors = new List<string>(12);

		private readonly Dictionary<StickerShape, Texture2D> _stickerStampTextures = new Dictionary<StickerShape, Texture2D>();

		private readonly PlacementEditState _decalPlacementEdit = new PlacementEditState();

		private readonly PlacementEditState _stickerPlacementEdit = new PlacementEditState();

		private bool _isOpen;

		private Vector2 _cursor;

		private int _selectedSuitId = -1;

		private int _selectedDesignIndex = -1;

		private int _selectedDecalIndex = -1;

		private string _designName = "MyDrawableSuit";

		private EditorTool _tool;

		private EditorTool _previousToolBeforeEyedropper;

		private BrushShape _brushShape;

		private Color _brushColor = Color.red;

		private float _brushSize = 16f;

		private float _brushOpacity = 1f;

		private float _fillTolerance = 0.08f;

		private float _decalSize = 128f;

		private float _decalRotation;

		private string _textStampValue = "TEXT";

		private float _textSize = 96f;

		private float _textRotation;

		private StickerShape _stickerShape = StickerShape.Star;

		private float _stickerSize = 128f;

		private float _stickerRotation;

		private bool _mirrorEnabled;

		private bool _strokeActive;

		private int _brushStrokeSeed = 1;

		private int _brushStrokeSequence;

		private bool _decalStampArmed = true;

		private bool _suppressPaintInputUntilRelease;

		private string _statusMessage = string.Empty;

		private bool _cursorStateCaptured;

		private bool _previousCursorVisible;

		private CursorLockMode _previousCursorLockState;

		private bool _playerInputStateCaptured;

		private bool _previousDisableMoveInput;

		private bool _previousDisableLookInput;

		private bool _previousDisableInteract;

		private bool _previousInSpecialMenu;

		private bool _previousMovementActionsEnabled;

		private PlayerControllerB _inputLockedPlayer;

		private bool _bootstrapShell;

		private bool _hasEditableSuit;

		private bool _hasLocalPlayer;

		private bool _hasPlayerModel;

		private bool _hasCamera;

		private bool _hasPreviewCollider;

		private bool _canPaint;

		private int _knownSuitCount;

		private float _lastPaintDiagnosticsTime;

		private string _lastPaintDiagnosticsKey = string.Empty;

		private float _lastMissingDecalWarningTime;

		private float _lastGameplayActionRelockLogTime;

		private float _lastMirrorDiagnosticsTime;

		private string _lastMirrorDiagnosticsKey = string.Empty;

		private float _lastEyedropperDiagnosticsTime;

		private string _lastEyedropperDiagnosticsKey = string.Empty;

		private float _lastFillBucketDiagnosticsTime;

		private string _lastFillBucketDiagnosticsKey = string.Empty;

		private static readonly string[] GameplayInputActionNames = new string[27]
		{
			"Move", "Look", "Jump", "Crouch", "Interact", "ItemSecondaryUse", "ItemTertiaryUse", "ActivateItem", "Discard", "SwitchItem",
			"ScrollMouse", "ItemScroll", "NextItem", "PreviousItem", "PingScan", "Scan", "InspectItem", "UseUtilitySlot", "ItemPrimaryUse", "ItemInteract",
			"BuildMode", "ConfirmBuildMode", "Delete", "Emote1", "Emote2", "SetFreeCamera", "SpeedCheat"
		};

		private readonly List<DisabledGameplayActionState> _disabledGameplayActions = new List<DisabledGameplayActionState>();

		private GameObject _previewRoot;

		private GameObject _previewRigRoot;

		private GameObject _previewPivotRoot;

		private Camera _previewCamera;

		private Light _previewLight;

		private RenderTexture _previewTexture;

		private Material _previewMaterial;

		private Mesh _previewMesh;

		private MeshCollider _previewCollider;

		private MeshRenderer _previewRenderer;

		private int _previewLayer = 2;

		private float _previewScale = 0.9f;

		private Texture2D _checkerTexture;

		private bool _usingTexturePreview = true;

		private string _previewMode = "Texture";

		private string _lastPreviewAssignmentLog = string.Empty;

		private Vector2 _lastPreviewUv;

		private bool _lastPreviewUvAvailable;

		private bool _uvFallbackMode;

		private float _uvPanelZoom = 1f;

		private Vector2 _uvPanelCenter = new Vector2(0.5f, 0.5f);

		private int _uvPanelRotationQuarterTurns;

		private int _uvPanelTextureWidth;

		private int _uvPanelTextureHeight;

		private string _lastUvPanelViewLogKey = string.Empty;

		private float _lastUvPanelViewLogTime;

		private GameObject _worldEditorCameraObject;

		private Camera _worldEditorCamera;

		private GameObject _worldPaintProxyObject;

		private Mesh _worldPaintMesh;

		private MeshCollider _worldPaintCollider;

		private MeshFilter _worldAvatarMeshFilter;

		private MeshRenderer _worldAvatarRenderer;

		private SkinnedMeshRenderer _worldSourceRenderer;

		private string _worldSourceRendererSummary = "none";

		private GameObject _worldBrushMarker;

		private Material _worldBrushMarkerMaterial;

		private Material _worldHiddenSubmeshMaterial;

		private Material _worldDecalPreviewMaterial;

		private int _worldPaintLayer = 30;

		private float _worldCameraYaw;

		private float _worldCameraPitch = 12f;

		private float _worldCameraDistance = 3.4f;

		private bool _worldPreviewReady;

		private string _lastWorldProxyMaterialLogKey = string.Empty;

		private float _lastWorldProxyMaterialLogTime;

		private Vector2 _lastWorldPaintUv;

		private Vector3 _lastWorldHitPoint;

		private Vector3 _lastWorldHitNormal;

		private Texture2D _decalPreviewTexture;

		private RawImage _uvDecalPreviewImage;

		private RectTransform _uvDecalPreviewRect;

		private RawImage _uvMirrorDecalPreviewImage;

		private RectTransform _uvMirrorDecalPreviewRect;

		private bool _worldDecalPreviewApplied;

		private bool _decalPreviewVisible;

		private bool _suppressDecalPreviewUntilRelease;

		private int _decalPreviewSerial;

		private EditorTool _placementPreviewTool = EditorTool.Decal;

		private string _lastDecalPreviewKey = string.Empty;

		private string _lastDecalPreviewLogKey = string.Empty;

		private float _lastDecalPreviewLogTime;

		private string _lastStickerPreviewLogKey = string.Empty;

		private float _lastStickerPreviewLogTime;

		private string _lastPlacementPreviewThrottleLogKey = string.Empty;

		private float _lastPlacementPreviewThrottleLogTime;

		private string _lastPlacementPreviewReuseLogKey = string.Empty;

		private float _lastPlacementPreviewReuseLogTime;

		private string _lastPlacementPreviewRebuildLogKey = string.Empty;

		private float _lastPlacementPreviewRebuildLogTime;

		private float _lastWorldPlacementPreviewRebuildTime;

		private Vector2 _lastPlacementPreviewCursor;

		private bool _lastPlacementPreviewCursorValid;

		private float _lastPlacementPreviewCursorMoveTime;

		private string _lastPlacementPreviewIdleTargetKey = string.Empty;

		private string _lastPlacementPreviewIdleLogKey = string.Empty;

		private float _lastPlacementPreviewIdleLogTime;

		private Color32[] _placementPreviewBasePixels;

		private Texture2D _placementPreviewBaseSource;

		private int _placementPreviewBaseSerial = -1;

		private string _lastDecalCoverageWarningKey = string.Empty;

		private float _lastDecalCoverageWarningTime;

		private string _lastBrushSurfaceDiagnosticsKey = string.Empty;

		private float _lastBrushSurfaceDiagnosticsTime;

		private string _lastBrushSurfaceWarningKey = string.Empty;

		private float _lastBrushSurfaceWarningTime;

		private string _lastTextPreviewLogKey = string.Empty;

		private float _lastTextPreviewLogTime;

		private string _lastTextProjectionFrameLogKey = string.Empty;

		private float _lastTextProjectionFrameLogTime;

		private int _designListPage;

		private int _decalListPage;

		private readonly List<RendererRestoreState> _rendererRestoreStates = new List<RendererRestoreState>();

		private Texture2D _loadedDecal;

		private Texture2D _editedDecalStampTexture;

		private Texture2D _editedStickerStampTexture;

		private Texture2D _editedDecalPreviewStampTexture;

		private Texture2D _editedStickerPreviewStampTexture;

		private string _editedDecalStampKey = string.Empty;

		private string _editedStickerStampKey = string.Empty;

		private string _editedDecalPreviewStampKey = string.Empty;

		private string _editedStickerPreviewStampKey = string.Empty;

		private PlacementSourcePixelCache _placementSourcePixelCache;

		private TextStampRenderer _textStampRenderer;

		private Texture2D _textStampTexture;

		private string _textStampTextureKey = string.Empty;

		private string _lastWorldProxyMeshSummary = "none";

		private MirrorSurfaceMap _mirrorSurfaceMap;

		private string _mirrorSurfaceMapKey = string.Empty;

		private GameObject _editorCanvasObject;

		private GameObject _cursorCanvasObject;

		private RectTransform _canvasRect;

		private RectTransform _cursorCanvasRect;

		private GameObject _canvasCursorObject;

		private RectTransform _canvasCursorRect;

		private DrawableCanvasCursorGraphic _canvasCursorGraphic;

		private RectTransform _panelRect;

		private RectTransform _previewViewportRect;

		private RectTransform _brushIndicator;

		private Image _brushIndicatorImage;

		private RectTransform _cursorMarker;

		private RectTransform _cursorBackRect;

		private RectTransform _cursorFrontRect;

		private Image _cursorBackImage;

		private Image _cursorImage;

		private Sprite _cursorDotSprite;

		private Sprite _cursorRingSprite;

		private Texture2D _cursorDotTexture;

		private Texture2D _cursorRingTexture;

		private Texture2D _nativeCursorTexture;

		private string _nativeCursorKey = string.Empty;

		private string _lastNativeCursorLogKey = string.Empty;

		private float _lastNativeCursorLogTime;

		private string _lastNativeCursorFailureKey = string.Empty;

		private float _lastNativeCursorFailureTime;

		private string _lastNativeCursorWarpKey = string.Empty;

		private float _lastNativeCursorWarpTime;

		private float _ignoreMouseInputUntilTime;

		private string _lastCanvasCursorLogKey = string.Empty;

		private float _lastCanvasCursorLogTime;

		private string _lastCanvasCursorHiddenKey = string.Empty;

		private float _lastCanvasCursorHiddenTime;

		private string _lastDynamicCursorLogKey = string.Empty;

		private float _lastDynamicCursorLogTime;

		private string _lastImmediateCursorSkipLog = string.Empty;

		private float _lastImmediateCursorSkipLogTime;

		private RectTransform _designListContent;

		private RectTransform _decalListContent;

		private Text _designEmptyLabel;

		private Text _decalEmptyLabel;

		private Text _undoHistoryEmptyLabel;

		private Text _undoHistorySelectionLabel;

		private Text _designPageLabel;

		private Text _decalPageLabel;

		private Button _designPrevPageButton;

		private Button _designNextPageButton;

		private Button _decalPrevPageButton;

		private Button _decalNextPageButton;

		private readonly List<AnchoredListRow> _designRows = new List<AnchoredListRow>();

		private readonly List<AnchoredListRow> _decalRows = new List<AnchoredListRow>();

		private readonly List<UndoHistoryRow> _undoHistoryRows = new List<UndoHistoryRow>();

		private long _nextUndoHistoryId = 1L;

		private long _selectedUndoHistoryId;

		private RotatedUvRawImage _previewImage;

		private Text _suitLabel;

		private Text _statusLabel;

		private Text _activeToolLabel;

		private Text _brushSizeLabel;

		private Text _brushOpacityLabel;

		private Text _brushShapeLabel;

		private Text _recentColorsLabel;

		private Text _decalSizeLabel;

		private Text _decalRotationLabel;

		private Text _placementHeaderLabel;

		private InputField _designNameInput;

		private InputField _textStampInput;

		private DrawableSliderControl _brushSizeSlider;

		private DrawableSliderControl _brushOpacitySlider;

		private Text _fillToleranceLabel;

		private DrawableSliderControl _fillToleranceSlider;

		private DrawableColorPickerControl _colorPicker;

		private InputField _colorHexInput;

		private DrawableSliderControl _decalSizeSlider;

		private DrawableSliderControl _decalRotationSlider;

		private Image _colorSwatch;

		private Button _paintButton;

		private Button _eraseButton;

		private Button _fillButton;

		private Button _decalButton;

		private Button _eyedropperButton;

		private Button _textButton;

		private Button _stickerButton;

		private Button _mirrorButton;

		private Button _brushShapeButton;

		private GameObject _brushShapeMenuObject;

		private readonly List<Button> _brushShapeOptionButtons = new List<Button>();

		private Button _stickerShapeButton;

		private GameObject _stickerShapeMenuObject;

		private readonly List<Button> _stickerShapeOptionButtons = new List<Button>();

		private Text _selectedDecalLabel;

		private Button _decalsMenuButton;

		private Button _editDecalButton;

		private Text _selectedStickerShapeLabel;

		private Button _stickersMenuButton;

		private Button _editStickerButton;

		private GameObject _decalsPanelObject;

		private Text _decalsStatusLabel;

		private GameObject _stickersPanelObject;

		private Text _stickersStatusLabel;

		private readonly List<Button> _stickerPanelShapeButtons = new List<Button>();

		private readonly List<Button> _recentColorButtons = new List<Button>(12);

		private readonly List<Image> _recentColorImages = new List<Image>(12);

		private Button _applyButton;

		private Button _saveButton;

		private Button _savedDesignsButton;

		private Button _loadSelectedDesignButton;

		private Button _deleteSelectedDesignButton;

		private Button _undoToSelectedButton;

		private Button _clearUndoHistoryButton;

		private Button _resetButton;

		private Button _exportCodeButton;

		private Button _importCodeButton;

		private Button _uvFallbackButton;

		private GameObject _designCodePanelObject;

		private InputField _designCodeInput;

		private Text _designCodeStatusLabel;

		private GameObject _savedDesignsPanelObject;

		private Text _savedDesignsStatusLabel;

		private Button _deleteSelectedDecalButton;

		private Button _addDecalButton;

		private GameObject _placementEditPanelObject;

		private PlacementEditTarget _activePlacementEditTarget;

		private RectTransform _placementEditPreviewFrameRect;

		private RectTransform _placementEditPreviewRect;

		private RawImage _placementEditPreviewBackingImage;

		private RawImage _placementEditPreviewImage;

		private Text _placementEditTitleLabel;

		private Text _placementEditSourceLabel;

		private Text _placementEditCropLeftLabel;

		private Text _placementEditCropRightLabel;

		private Text _placementEditCropBottomLabel;

		private Text _placementEditCropTopLabel;

		private Text _placementEditStretchXLabel;

		private Text _placementEditStretchYLabel;

		private Text _placementEditStatusLabel;

		private Button _placementEditFlipXButton;

		private Button _placementEditFlipYButton;

		private DrawableSliderControl _placementEditCropLeftSlider;

		private DrawableSliderControl _placementEditCropRightSlider;

		private DrawableSliderControl _placementEditCropBottomSlider;

		private DrawableSliderControl _placementEditCropTopSlider;

		private DrawableSliderControl _placementEditStretchXSlider;

		private DrawableSliderControl _placementEditStretchYSlider;

		private readonly Dictionary<PlacementFilter, Text> _placementEditFilterValueLabels = new Dictionary<PlacementFilter, Text>();

		private readonly Dictionary<PlacementFilter, DrawableSliderControl> _placementEditFilterSliders = new Dictionary<PlacementFilter, DrawableSliderControl>();

		private Texture2D _placementEditCheckerTexture;

		private string _lastPlacementEditPreviewLogKey = string.Empty;

		private float _lastPlacementEditPreviewLogTime;

		private string _lastPlacementSourcePixelsLogKey = string.Empty;

		private float _lastPlacementSourcePixelsLogTime;

		private Color32[] _editedDecalPreviewPixelBuffer;

		private string _pendingDeleteDesignPath = string.Empty;

		private string _pendingDeleteDecalPath = string.Empty;

		private GameObject _editorEventSystemObject;

		private EventSystem _editorEventSystem;

		private InputSystemUIInputModule _editorInputModule;

		private InputActionAsset _editorUiActions;

		private bool _editorUiInputActive;

		private bool _virtualPointerDown;

		private GameObject _virtualPointerPressTarget;

		private DrawableSliderControl _virtualPointerSlider;

		private DrawableColorPickerControl _virtualPointerColorPicker;

		private Button _virtualPointerButton;

		private InputField _virtualPointerInput;

		private string _pointerSource = "Mouse";

		private Vector2 _lastMousePosition;

		private Vector2 _lastGamepadStick;

		private bool _mousePositionAvailable;

		private bool _usingGamepadPointer;

		private bool _gamepadClickArmed;

		private float _lastUiDiagnosticsTime;

		private readonly List<EventSystemRestoreState> _eventSystemRestoreStates = new List<EventSystemRestoreState>();

		internal bool IsOpenForDiagnostics => _isOpen;

		internal bool CanvasActiveForDiagnostics
		{
			get
			{
				if ((Object)(object)_editorCanvasObject != (Object)null)
				{
					return _editorCanvasObject.activeSelf;
				}
				return false;
			}
		}

		private bool IsWorldThirdPersonMode => string.Equals(_previewMode, "WorldThirdPerson", StringComparison.OrdinalIgnoreCase);

		private void Start()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			_cursor = new Vector2((float)Screen.width * 0.5f, (float)Screen.height * 0.5f);
			LoadRecentColors();
			RefreshFileLists();
			DrawableSuitsDiagnostics.Info($"SuitEditorController.Start complete. Screen={Screen.width}x{Screen.height}; designFiles={_designFiles.Count}; decalFiles={_decalFiles.Count}; recentColors={_recentColors.Count}");
		}

		private void OnDestroy()
		{
			if (_isOpen)
			{
				CloseEditor(EditorCloseReason.PluginDestroy);
			}
			else
			{
				EndEditorUiInput();
				DestroyPreview();
			}
			if ((Object)(object)_loadedDecal != (Object)null)
			{
				ClearPlacementSourcePixelCache(PlacementEditTarget.Decal, "controller destroyed loaded decal");
				Object.Destroy((Object)(object)_loadedDecal);
				_loadedDecal = null;
			}
			if ((Object)(object)_checkerTexture != (Object)null)
			{
				Object.Destroy((Object)(object)_checkerTexture);
				_checkerTexture = null;
			}
			DestroyPlacementEditResources();
			ResetNativeCursor("plugin destroy");
			DestroyCursorGraphics();
			if (_textStampRenderer != null)
			{
				_textStampRenderer.Destroy();
				_textStampRenderer = null;
				_textStampTexture = null;
			}
			foreach (Texture2D value in _stickerStampTextures.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)value);
				}
			}
			_stickerStampTextures.Clear();
			if ((Object)(object)_editorCanvasObject != (Object)null)
			{
				Object.Destroy((Object)(object)_editorCanvasObject);
				_editorCanvasObject = null;
			}
			if ((Object)(object)_cursorCanvasObject != (Object)null)
			{
				DestroyLegacyCursorCanvas("plugin destroy");
			}
			DestroyCanvasCursor("plugin destroy");
			if ((Object)(object)_editorEventSystemObject != (Object)null)
			{
				Object.Destroy((Object)(object)_editorEventSystemObject);
				_editorEventSystemObject = null;
			}
			if ((Object)(object)_editorUiActions != (Object)null)
			{
				Object.Destroy((Object)(object)_editorUiActions);
				_editorUiActions = null;
			}
		}

		private void Update()
		{
			if (!_isOpen)
			{
				return;
			}
			if (DrawableSuitsInput.WasKeyPressed((Key)60) || WasGamepadPressed((Gamepad g) => g.buttonEast))
			{
				CloseEditor(EditorCloseReason.Shortcut);
				return;
			}
			ReapplyPlayerInputLock();
			EnsureCursorUnlockedWhileOpen();
			HandleControllerCursor();
			UpdateCanvasCursor(force: false, "update");
			if (IsWorldThirdPersonMode)
			{
				UpdateWorldEditorCamera(forceLog: false);
			}
			HandleVirtualCursorClick();
			HandleEditorShortcuts();
			if (IsWorldThirdPersonMode)
			{
				UpdateWorldBrushMarker();
			}
			else
			{
				UpdateBrushIndicator();
			}
			UpdateDecalPlacementPreview();
			HandlePaintingInput();
			if (DrawableSuitsPlugin.ModConfig.EnableExperimentalModelPreview.Value && !_usingTexturePreview && !IsWorldThirdPersonMode)
			{
				UpdatePreviewTransform();
				RenderPreviewFrame();
			}
			LogUiInputDiagnosticsIfNeeded();
		}

		public bool OpenEditor()
		{
			return OpenEditor("Direct");
		}

		public bool OpenEditor(string source)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			object arg = _isOpen;
			Scene activeScene = SceneManager.GetActiveScene();
			DrawableSuitsDiagnostics.Info($"OpenEditor requested. source={source}; isOpen={arg}; activeScene={((Scene)(ref activeScene)).name}");
			if (_isOpen)
			{
				RefreshEditorReadiness("open request while already open");
				UpdateUiState();
				LogCanvasState("already-open");
				return true;
			}
			if (!EnsureEditorCanvas(out var failureReason))
			{
				DrawableSuitsDiagnostics.Warn(failureReason);
				return false;
			}
			BeginEditorUiInput();
			RefreshEditorReadiness("before show (" + source + ")");
			CaptureAndUnlockCursor();
			CaptureAndLockPlayerInput();
			ResetNativeCursor("open start");
			_isOpen = true;
			_editorCanvasObject.SetActive(true);
			DestroyLegacyCursorCanvas("open from " + source);
			InitializePointerForOpen(source);
			EnsureCanvasCursor();
			UpdateCanvasCursor(force: true, "open from " + source);
			RefreshFileLists();
			_uvFallbackMode = DrawableSuitsPlugin.ModConfig.StartInUvFallbackMode.Value;
			ResetUvPanelView("open from " + source, forceLog: false);
			ResetPlacementEdits("editor open", log: false);
			EnsureValidToolForCurrentState("open from " + source);
			TryRebuildPreviewForCurrentReadiness(source);
			RefreshEditorReadiness("after preview (" + source + ")");
			UpdateUiState();
			RebuildSelectableNavigation();
			LogEditorControlTree((Transform)(object)_panelRect);
			LogCanvasState("opened from " + source);
			DrawableSuitsDiagnostics.Info("DrawableSuits editor overlay opened.");
			return true;
		}

		public void CloseEditor()
		{
			CloseEditor(EditorCloseReason.Normal);
		}

		public void CloseEditor(string source)
		{
			CloseEditor(GetCloseReasonFromSource(source));
		}

		public void CloseEditorForSceneChange()
		{
			CloseEditor(EditorCloseReason.SceneChange);
		}

		public void CloseEditorForPluginDestroy()
		{
			CloseEditor(EditorCloseReason.PluginDestroy);
		}

		internal int RepairClosedEditorState(string reason)
		{
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			if (_isOpen)
			{
				return 0;
			}
			int num = 0;
			if ((Object)(object)_editorCanvasObject != (Object)null && _editorCanvasObject.activeSelf)
			{
				_editorCanvasObject.SetActive(false);
				num++;
			}
			if ((Object)(object)_previewRoot != (Object)null || (Object)(object)_previewRigRoot != (Object)null || (Object)(object)_previewCamera != (Object)null || (Object)(object)_previewTexture != (Object)null || (Object)(object)_worldEditorCameraObject != (Object)null || (Object)(object)_worldEditorCamera != (Object)null || (Object)(object)_worldPaintProxyObject != (Object)null || (Object)(object)_worldBrushMarker != (Object)null)
			{
				DestroyPreview();
				num++;
			}
			if (_editorUiInputActive)
			{
				EndEditorUiInput();
				num++;
			}
			if (_playerInputStateCaptured || _disabledGameplayActions.Count > 0)
			{
				RestorePlayerInputState();
				num++;
			}
			if (_cursorStateCaptured)
			{
				RestoreCursorState(IsSceneChangeSafetyReason(reason));
				num++;
			}
			if ((Object)(object)_cursorCanvasObject != (Object)null)
			{
				DestroyLegacyCursorCanvas("repair closed state " + reason);
				num++;
			}
			if ((Object)(object)_canvasCursorObject != (Object)null && _canvasCursorObject.activeSelf)
			{
				HideCanvasCursor("repair closed state " + reason, forceLog: true);
				num++;
			}
			if (!string.IsNullOrEmpty(_nativeCursorKey) || (Object)(object)_nativeCursorTexture != (Object)null)
			{
				ResetNativeCursor("repair closed state " + reason);
				num++;
			}
			if (_rendererRestoreStates.Count > 0)
			{
				RestorePlayerRenderers();
				num++;
			}
			if (num > 0)
			{
				DrawableSuitsDiagnostics.Info($"ClosedEditorStateAssertion reason={reason}; repaired={num}; canvasActive={CanvasActiveForDiagnostics}; editorUiInputActive={_editorUiInputActive}; playerInputCaptured={_playerInputStateCaptured}; cursorCaptured={_cursorStateCaptured}; rendererRestoreStates={_rendererRestoreStates.Count}; cursorVisible={Cursor.visible}; cursorLock={Cursor.lockState}");
			}
			return num;
		}

		private static bool IsSceneChangeSafetyReason(string reason)
		{
			if (!string.IsNullOrWhiteSpace(reason))
			{
				if (reason.IndexOf("Scene", StringComparison.OrdinalIgnoreCase) < 0 && reason.IndexOf("MainMenu", StringComparison.OrdinalIgnoreCase) < 0)
				{
					return reason.IndexOf("InitScene", StringComparison.OrdinalIgnoreCase) >= 0;
				}
				return true;
			}
			return false;
		}

		private void CloseEditor(EditorCloseReason reason)
		{
			if (_isOpen)
			{
				DrawableSuitsDiagnostics.Info($"Closing DrawableSuits editor. reason={reason}");
				_isOpen = false;
				CloseDesignCodePanel();
				CloseSavedDesignsPanel();
				CloseDecalsPanel();
				CloseStickersPanel();
				ClosePlacementEditPanel();
				ResetPlacementEdits($"close {reason}", log: true);
				HideCanvasCursor($"close {reason}", forceLog: true);
				if ((Object)(object)_editorCanvasObject != (Object)null)
				{
					_editorCanvasObject.SetActive(false);
				}
				DestroyLegacyCursorCanvas($"close {reason}");
				ResetNativeCursor($"close {reason}");
				DestroyPreview();
				_strokeActive = false;
				_virtualPointerDown = false;
				_virtualPointerPressTarget = null;
				_virtualPointerSlider = null;
				_virtualPointerColorPicker = null;
				_virtualPointerButton = null;
				_virtualPointerInput = null;
				_gamepadClickArmed = false;
				RestorePlayerInputState();
				EndEditorUiInput();
				RestoreCursorState(reason == EditorCloseReason.SceneChange);
			}
		}

		public bool ToggleEditor()
		{
			return ToggleEditor("Direct");
		}

		public bool ToggleEditor(string source)
		{
			if (_isOpen)
			{
				DrawableSuitsDiagnostics.Info("ToggleEditor closing from source=" + source + ".");
				CloseEditor(GetCloseReasonFromSource(source));
				return true;
			}
			DrawableSuitsDiagnostics.Info("ToggleEditor opening from source=" + source + ".");
			return OpenEditor(source);
		}

		public void OpenFromPauseMenuNextFrame(QuickMenuManager quickMenu)
		{
			DrawableSuitsDiagnostics.Info($"Pause-menu open scheduled for next frame. quickMenuNull={(Object)(object)quickMenu == (Object)null}; menuOpen={quickMenu?.isMenuOpen}");
			((MonoBehaviour)this).StartCoroutine(OpenFromPauseMenuNextFrameRoutine(quickMenu));
		}

		private IEnumerator OpenFromPauseMenuNextFrameRoutine(QuickMenuManager quickMenu)
		{
			yield return null;
			object[] obj = new object[6]
			{
				(Object)(object)quickMenu == (Object)null,
				quickMenu?.isMenuOpen,
				Cursor.visible,
				Cursor.lockState,
				null,
				null
			};
			EventSystem current = EventSystem.current;
			obj[4] = ((current != null) ? ((Object)current).name : null) ?? "null";
			EventSystem current2 = EventSystem.current;
			obj[5] = ((current2 == null) ? null : ((object)current2.currentInputModule)?.GetType().Name) ?? "null";
			DrawableSuitsDiagnostics.Info(string.Format("Pause-menu delayed open before OpenEditor. quickMenuNull={0}; menuOpen={1}; cursorVisible={2}; cursorLock={3}; eventSystem={4}; inputModule={5}", obj));
			bool flag = OpenEditor("PauseMenuButton");
			object[] obj2 = new object[7]
			{
				flag,
				_isOpen,
				CanvasActiveForDiagnostics,
				Cursor.visible,
				Cursor.lockState,
				null,
				null
			};
			EventSystem current3 = EventSystem.current;
			obj2[5] = ((current3 != null) ? ((Object)current3).name : null) ?? "null";
			EventSystem current4 = EventSystem.current;
			obj2[6] = ((current4 == null) ? null : ((object)current4.currentInputModule)?.GetType().Name) ?? "null";
			DrawableSuitsDiagnostics.Info(string.Format("Pause-menu delayed open after OpenEditor. opened={0}; isOpen={1}; canvasActive={2}; cursorVisible={3}; cursorLock={4}; eventSystem={5}; inputModule={6}", obj2));
		}

		private static EditorCloseReason GetCloseReasonFromSource(string source)
		{
			if (!string.IsNullOrWhiteSpace(source) && source.IndexOf("Pause", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return EditorCloseReason.PauseMenu;
			}
			if (!string.IsNullOrWhiteSpace(source) && source.IndexOf("Scene", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return EditorCloseReason.SceneChange;
			}
			return EditorCloseReason.Shortcut;
		}

		private void RefreshEditorReadiness(string context)
		{
			int selectedSuitId = _selectedSuitId;
			int localSuitId = DrawableSuitsPlugin.Registry.GetLocalSuitId();
			List<int> suitIds = DrawableSuitsPlugin.Registry.GetSuitIds();
			_knownSuitCount = suitIds.Count;
			_selectedSuitId = localSuitId;
			if (selectedSuitId != _selectedSuitId)
			{
				ClearUndoHistory("current suit changed");
				InvalidateDecalPreview("current suit changed");
				InvalidateMirrorSurfaceMap("current suit changed");
				DrawableSuitsDiagnostics.Info($"Current local suit selected by readiness. context={context}; previous={selectedSuitId}; current={_selectedSuitId}; known={suitIds.Contains(_selectedSuitId)}");
			}
			PlayerControllerB val = StartOfRound.Instance?.localPlayerController;
			_hasLocalPlayer = (Object)(object)val != (Object)null;
			_hasPlayerModel = (Object)(object)val?.thisPlayerModel != (Object)null;
			_hasCamera = (Object)(object)Camera.main != (Object)null;
			_hasPreviewCollider = (Object)(object)_previewCollider != (Object)null || (Object)(object)_worldPaintCollider != (Object)null;
			Texture2D val2 = ((_selectedSuitId >= 0) ? DrawableSuitsPlugin.Registry.GetEditableTexture(_selectedSuitId) : null);
			_hasEditableSuit = (Object)(object)val2 != (Object)null;
			_canPaint = (Object)(object)val2 != (Object)null && (_usingTexturePreview || _worldPreviewReady || (Object)(object)_previewCollider != (Object)null);
			SetStatus(BuildReadinessStatus(), warn: false);
			DrawableSuitsDiagnostics.Info($"Readiness[{context}]: selectedSuitId={_selectedSuitId}; suitCount={_knownSuitCount}; hasEditableSuit={_hasEditableSuit}; editableTexture={DescribeEditableTexture()}; hasLocalPlayer={_hasLocalPlayer}; hasPlayerModel={_hasPlayerModel}; hasCamera={_hasCamera}; previewMode={_previewMode}; hasPreviewCollider={_hasPreviewCollider}; canPaint={_canPaint}; status='{_statusMessage}'");
		}

		private string BuildReadinessStatus()
		{
			List<string> list = new List<string>();
			if (_knownSuitCount == 0)
			{
				list.Add("no suits registered yet");
			}
			if (_selectedSuitId < 0)
			{
				list.Add("local player current suit not available");
			}
			if (!_hasEditableSuit)
			{
				list.Add("current suit has no editable material/texture");
			}
			if (list.Count > 0)
			{
				return "Diagnostics: " + string.Join("; ", list);
			}
			return "Ready. Preview: " + _previewMode + ". Full-suit editing.";
		}

		private bool EnsureEditorCanvas(out string failureReason)
		{
			failureReason = string.Empty;
			if ((Object)(object)_editorCanvasObject != (Object)null)
			{
				LogCanvasState("ensure-existing");
				return true;
			}
			try
			{
				DrawableSuitsDiagnostics.Info("Building DrawableSuits editor UGUI canvas.");
				BuildEditorCanvas();
				LogCanvasState("ensure-created");
				return (Object)(object)_editorCanvasObject != (Object)null;
			}
			catch (Exception ex)
			{
				DrawableSuitsDiagnostics.Exception("BuildEditorCanvas failed", ex);
				if ((Object)(object)_editorCanvasObject != (Object)null)
				{
					Object.Destroy((Object)(object)_editorCanvasObject);
					_editorCanvasObject = null;
					_canvasRect = null;
					_panelRect = null;
					_cursorMarker = null;
				}
				failureReason = "DrawableSuits editor cannot open: failed to build Unity UI overlay (" + ex.Message + "). Check BepInEx/config/DrawableSuits/Logs/diagnostics.log for details.";
				return false;
			}
		}

		private void BuildEditorCanvas()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0073: 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_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0422: Unknown result type (might be due to invalid IL or missing references)
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_045b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0460: Unknown result type (might be due to invalid IL or missing references)
			//IL_0498: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0508: Unknown result type (might be due to invalid IL or missing references)
			//IL_0540: Unknown result type (might be due to invalid IL or missing references)
			//IL_0578: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0620: Unknown result type (might be due to invalid IL or missing references)
			//IL_0655: Unknown result type (might be due to invalid IL or missing references)
			//IL_0687: Unknown result type (might be due to invalid IL or missing references)
			//IL_068c: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0730: Unknown result type (might be due to invalid IL or missing references)
			//IL_0763: Unknown result type (might be due to invalid IL or missing references)
			//IL_0768: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_07eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_082f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0873: Unknown result type (might be due to invalid IL or missing references)
			//IL_0878: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_091e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0923: Unknown result type (might be due to invalid IL or missing references)
			//IL_0949: Unknown result type (might be due to invalid IL or missing references)
			//IL_094f: Unknown result type (might be due to invalid IL or missing references)
			//IL_09d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_09dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a0d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a34: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a69: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a9c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ad9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ade: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b1d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b61: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b66: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ba5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0be6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c4f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c7e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cb9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d2e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d69: Unknown result type (might be due to invalid IL or missing references)
			//IL_0daa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ddc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0de1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e06: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e38: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e3d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e69: Unknown result type (might be due to invalid IL or missing references)
			//IL_0eb4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0eef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f29: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f5f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f96: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fd1: Unknown result type (might be due to invalid IL or missing references)
			//IL_100c: Unknown result type (might be due to invalid IL or missing references)
			//IL_1047: Unknown result type (might be due to invalid IL or missing references)
			//IL_107c: Unknown result type (might be due to invalid IL or missing references)
			//IL_10ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_10b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_10d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_113c: Unknown result type (might be due to invalid IL or missing references)
			//IL_1197: Unknown result type (might be due to invalid IL or missing references)
			//IL_11a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_11ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_11f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_1204: Unknown result type (might be due to invalid IL or missing references)
			//IL_120e: Unknown result type (might be due to invalid IL or missing references)
			//IL_1250: Unknown result type (might be due to invalid IL or missing references)
			//IL_1260: Unknown result type (might be due to invalid IL or missing references)
			//IL_12c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_12dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_12f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_1306: Unknown result type (might be due to invalid IL or missing references)
			//IL_1320: Unknown result type (might be due to invalid IL or missing references)
			//IL_1355: Unknown result type (might be due to invalid IL or missing references)
			//IL_13c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_13e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_13fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_140c: Unknown result type (might be due to invalid IL or missing references)
			//IL_1426: Unknown result type (might be due to invalid IL or missing references)
			//IL_145b: Unknown result type (might be due to invalid IL or missing references)
			//IL_14ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_1503: Unknown result type (might be due to invalid IL or missing references)
			//IL_155a: Unknown result type (might be due to invalid IL or missing references)
			//IL_155f: Unknown result type (might be due to invalid IL or missing references)
			//IL_15b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_15c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_15cb: Unknown result type (might be due to invalid IL or missing references)
			_bootstrapShell = false;
			_editorCanvasObject = new GameObject("DrawableSuitsEditorCanvas", new Type[4]
			{
				typeof(RectTransform),
				typeof(Canvas),
				typeof(CanvasScaler),
				typeof(GraphicRaycaster)
			});
			Object.DontDestroyOnLoad((Object)(object)_editorCanvasObject);
			_canvasRect = _editorCanvasObject.GetComponent<RectTransform>();
			_canvasRect.anchorMin = Vector2.zero;
			_canvasRect.anchorMax = Vector2.one;
			_canvasRect.offsetMin = Vector2.zero;
			_canvasRect.offsetMax = Vector2.zero;
			Canvas component = _editorCanvasObject.GetComponent<Canvas>();
			component.renderMode = (RenderMode)0;
			component.sortingOrder = 32760;
			CanvasScaler component2 = _editorCanvasObject.GetComponent<CanvasScaler>();
			component2.uiScaleMode = (ScaleMode)1;
			component2.referenceResolution = new Vector2(1920f, 1080f);
			component2.matchWidthOrHeight = 0.5f;
			GameObject val = CreateUiObject("EditorPanel", _editorCanvasObject.transform, typeof(Image));
			_panelRect = val.GetComponent<RectTransform>();
			_panelRect.anchorMin = new Vector2(0f, 1f);
			_panelRect.anchorMax = new Vector2(0f, 1f);
			_panelRect.pivot = new Vector2(0f, 1f);
			_panelRect.anchoredPosition = new Vector2(24f, -24f);
			_panelRect.sizeDelta = new Vector2(620f, 1010f);
			Image component3 = val.GetComponent<Image>();
			((Graphic)component3).color = TerminalPanelColor;
			ApplyTerminalOutline(val, TerminalOutlineColor);
			CreateAnchoredText(val.transform, "Title", "DrawableSuits 0.5.77", 24, (FontStyle)1, (TextAnchor)3, new Rect(18f, 12f, 360f, 34f), TerminalStatusColor);
			CreateAnchoredButton(val.transform, "Close", new Rect(512f, 14f, 88f, 34f), CloseEditor);
			_suitLabel = CreateAnchoredText(val.transform, "SuitLabel", string.Empty, 18, (FontStyle)0, (TextAnchor)3, new Rect(18f, 54f, 420f, 28f), TerminalTextColor);
			_statusLabel = CreateAnchoredText(val.transform, "StatusLabel", string.Empty, 15, (FontStyle)0, (TextAnchor)0, new Rect(18f, 86f, 274f, 50f), TerminalStatusColor);
			((Graphic)_statusLabel).color = TerminalStatusColor;
			CreateAnchoredText(val.transform, "WorldHelp", "Aim suit/UV. RT use; hold paint/erase.\nWheel/D-pad zoom. D-pad L/R or ,/. rotate stamps.\nLB/RB or [ ] rotate UV.", 12, (FontStyle)0, (TextAnchor)0, new Rect(314f, 86f, 286f, 62f), TerminalMutedTextColor);
			CreateSectionCard(val.transform, new Rect(10f, 150f, 290f, 112f));
			CreateSectionCard(val.transform, new Rect(10f, 270f, 290f, 150f));
			CreateSectionCard(val.transform, new Rect(10f, 432f, 290f, 264f));
			CreateSectionCard(val.transform, new Rect(306f, 150f, 302f, 228f));
			CreateSectionCard(val.transform, new Rect(306f, 390f, 302f, 214f));
			CreateSectionCard(val.transform, new Rect(306f, 608f, 302f, 204f));
			CreateSectionDivider(val.transform, new Rect(18f, 150f, 274f, 1f));
			CreateAnchoredText(val.transform, "ToolHeader", "Tools", 16, (FontStyle)1, (TextAnchor)3, new Rect(18f, 158f, 72f, 24f), TerminalTextColor);
			_activeToolLabel = CreateAnchoredText(val.transform, "ActiveToolLabel", string.Empty, 13, (FontStyle)0, (TextAnchor)5, new Rect(104f, 158f, 188f, 24f), TerminalMutedTextColor);
			float num = 186f;
			float num2 = 228f;
			_paintButton = CreateAnchoredIconButton(val.transform, "Paint", ToolIconKind.Paint, new Rect(18f, num, 42f, 34f), delegate
			{
				SetTool(EditorTool.Paint);
			});
			_eraseButton = CreateAnchoredIconButton(val.transform, "Erase", ToolIconKind.Erase, new Rect(68f, num, 42f, 34f), delegate
			{
				SetTool(EditorTool.Erase);
			});
			_fillButton = CreateAnchoredIconButton(val.transform, "Fill", ToolIconKind.Fill, new Rect(118f, num, 42f, 34f), delegate
			{
				SetTool(EditorTool.FillBucket);
			});
			_mirrorButton = CreateAnchoredIconButton(val.transform, "Mirror", ToolIconKind.Mirror, new Rect(168f, num, 42f, 34f), ToggleMirror);
			_decalButton = CreateAnchoredIconButton(val.transform, "Decal", ToolIconKind.Decal, new Rect(18f, num2, 42f, 34f), delegate
			{
				SetTool(EditorTool.Decal);
			});
			_textButton = CreateAnchoredIconButton(val.transform, "Text", ToolIconKind.Text, new Rect(68f, num2, 42f, 34f), delegate
			{
				SetTool(EditorTool.Text);
			});
			_stickerButton = CreateAnchoredIconButton(val.transform, "Sticker", ToolIconKind.Sticker, new Rect(118f, num2, 42f, 34f), delegate
			{
				SetTool(EditorTool.Sticker);
			});
			_eyedropperButton = CreateAnchoredIconButton(val.transform, "Eyedropper", ToolIconKind.Eyedropper, new Rect(168f, num2, 42f, 34f), delegate
			{
				SetTool(EditorTool.Eyedropper);
			});
			CreateSectionDivider(val.transform, new Rect(18f, 270f, 274f, 1f));
			CreateAnchoredText(val.transform, "BrushHeader", "Brush", 16, (FontStyle)1, (TextAnchor)3, new Rect(18f, 278f, 274f, 24f), TerminalTextColor);
			_brushShapeLabel = CreateAnchoredText(val.transform, "BrushShapeLabel", "Shape", 14, (FontStyle)0, (TextAnchor)3, new Rect(18f, 308f, 94f, 24f), TerminalTextColor);
			_brushShapeButton = CreateAnchoredButton(val.transform, BrushShapeDisplayName(_brushShape), new Rect(118f, 304f, 174f, 30f), ToggleBrushShapeMenu);
			BuildBrushShapeMenu(val.transform, new Rect(118f, 336f, 174f, 178f));
			_brushSizeLabel = CreateAnchoredText(val.transform, "BrushSizeLabel", string.Empty, 14, (FontStyle)0, (TextAnchor)3, new Rect(18f, 342f, 94f, 24f), TerminalTextColor);
			_brushSizeSlider = CreateAnchoredSlider(val.transform, "BrushSize", 1f, 96f, _brushSize, new Rect(118f, 344f, 174f, 24f), delegate(float value)
			{
				_brushSize = value;
			});
			_brushOpacityLabel = CreateAnchoredText(val.transform, "BrushOpacityLabel", string.Empty, 14, (FontStyle)0, (TextAnchor)3, new Rect(18f, 376f, 94f, 24f), TerminalTextColor);
			_brushOpacitySlider = CreateAnchoredSlider(val.transform, "BrushOpacity", 0.05f, 1f, _brushOpacity, new Rect(118f, 378f, 174f, 24f), delegate(float value)
			{
				_brushOpacity = value;
			});
			_fillToleranceLabel = CreateAnchoredText(val.transform, "FillToleranceLabel", string.Empty, 14, (FontStyle)0, (TextAnchor)3, new Rect(18f, 408f, 104f, 24f), TerminalTextColor);
			_fillToleranceSlider = CreateAnchoredSlider(val.transform, "FillTolerance", 0f, 0.5f, _fillTolerance, new Rect(128f, 410f, 164f, 24f), delegate(float value)
			{
				_fillTolerance = value;
			});
			CreateSectionDivider(val.transform, new Rect(18f, 432f, 274f, 1f));
			CreateAnchoredText(val.transform, "ColorHeader", "Color", 16, (FontStyle)1, (TextAnchor)3, new Rect(18f, 440f, 274f, 24f), TerminalTextColor);
			_colorPicker = CreateAnchoredColorPicker(val.transform, new Rect(18f, 466f, 274f, 104f), _brushColor, delegate(Color color)
			{
				//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)
				_brushColor = color;
				UpdateColorUi();
			}, out _colorSwatch, out _colorHexInput);
			((UnityEvent<string>)(object)_colorHexInput.onValueChanged).AddListener((UnityAction<string>)PreviewHexInput);
			((UnityEvent<string>)(object)_colorHexInput.onEndEdit).AddListener((UnityAction<string>)ApplyHexInput);
			_recentColorsLabel = CreateAnchoredText(val.transform, "RecentColorsHeader", "Recent Colors", 14, (FontStyle)1, (TextAnchor)3, new Rect(18f, 582f, 274f, 22f), TerminalTextColor);
			Rect rect = default(Rect);
			((Rect)(ref rect))..ctor(18f, 608f, 274f, 68f);
			BuildRecentColorSwatches(val.transform, rect);
			_uvFallbackButton = CreateAnchoredButton(val.transform, "Use UV Fallback", new Rect(314f, 54f, 150f, 34f), ToggleUvFallback);
			CreateSectionDivider(val.transform, new Rect(314f, 150f, 286f, 1f));
			_placementHeaderLabel = CreateAnchoredText(val.transform, "PlacementHeader", "Decal", 16, (FontStyle)1, (TextAnchor)3, new Rect(314f, 158f, 286f, 24f), TerminalTextColor);
			_decalSizeLabel = CreateAnchoredText(val.transform, "DecalSizeLabel", string.Empty, 14, (FontStyle)0, (TextAnchor)3, new Rect(314f, 190f, 112f, 24f), TerminalTextColor);
			_decalSizeSlider = CreateAnchoredSlider(val.transform, "DecalSize", 16f, 512f, _decalSize, new Rect(434f, 192f, 160f, 24f), delegate(float value)
			{
				if (_tool == EditorTool.Text)
				{
					_textSize = value;
				}
				else if (_tool == EditorTool.Sticker)
				{
					_stickerSize = value;
				}
				else
				{
					_decalSize = value;
				}
				InvalidateDecalPreview("placement size changed");
			});
			_decalRotationLabel = CreateAnchoredText(val.transform, "DecalRotationLabel", string.Empty, 14, (FontStyle)0, (TextAnchor)3, new Rect(314f, 224f, 112f, 24f), TerminalTextColor);
			_decalRotationSlider = CreateAnchoredSlider(val.transform, "DecalRotation", -180f, 180f, _decalRotation, new Rect(434f, 226f, 160f, 24f), delegate(float value)
			{
				if (_tool == EditorTool.Text)
				{
					_textRotation = value;
				}
				else if (_tool == EditorTool.Sticker)
				{
					_stickerRotation = value;
				}
				else
				{
					_decalRotation = value;
				}
				InvalidateDecalPreview("placement rotation changed");
			});
			_textStampInput = CreateAnchoredInputField(val.transform, "TextStampInput", _textStampValue, new Rect(314f, 266f, 142f, 34f));
			_textStampInput.characterLimit = 64;
			_textStampInput.lineType = (LineType)0;
			((UnityEvent<string>)(object)_textStampInput.onValueChanged).AddListener((UnityAction<string>)delegate(string value)
			{
				_textStampValue = NormalizeTextStampValue(value);
				InvalidateTextStampTexture("text input changed");
				InvalidateDecalPreview("text input changed");
			});
			_selectedDecalLabel = CreateAnchoredValueLabel(val.transform, "SelectedDecalLabel", "No decal selected", new Rect(314f, 304f, 139f, 34f));
			_decalsMenuButton = CreateAnchoredButton(val.transform, "Decals", new Rect(461f, 266f, 139f, 34f), OpenDecalsPanel);
			_editDecalButton = CreateAnchoredButton(val.transform, "Edit Decal", new Rect(461f, 304f, 139f, 34f), delegate
			{
				OpenPlacementEditPanel(PlacementEditTarget.Decal);
			});
			_selectedStickerShapeLabel = CreateAnchoredValueLabel(val.transform, "SelectedStickerShapeLabel", StickerShapeDisplayName(_stickerShape), new Rect(314f, 304f, 139f, 34f));
			_stickersMenuButton = CreateAnchoredButton(val.transform, "Stickers", new Rect(461f, 266f, 139f, 34f), OpenStickersPanel);
			_editStickerButton = CreateAnchoredButton(val.transform, "Edit Sticker", new Rect(461f, 304f, 139f, 34f), delegate
			{
				OpenPlacementEditPanel(PlacementEditTarget.Sticker);
			});
			_stickerShapeButton = _stickersMenuButton;
			CreateSectionDivider(val.transform, new Rect(314f, 390f, 286f, 1f));
			CreateAnchoredText(val.transform, "UvPanelHeader", "UV Panel", 16, (FontStyle)1, (TextAnchor)3, new Rect(314f, 398f, 286f, 22f), TerminalTextColor);
			CreateSectionDivider(val.transform, new Rect(314f, 608f, 286f, 1f));
			CreateAnchoredText(val.transform, "DesignHeader", "Design Name", 16, (FontStyle)1, (TextAnchor)3, new Rect(314f, 616f, 286f, 24f), TerminalTextColor);
			_designNameInput = CreateAnchoredInputField(val.transform, _designName, new Rect(314f, 646f, 286f, 34f));
			((UnityEvent<string>)(object)_designNameInput.onValueChanged).AddListener((UnityAction<string>)delegate(string value)
			{
				_designName = value;
			});
			_exportCodeButton = CreateAnchoredButton(val.transform, "Export Code", new Rect(314f, 686f, 139f, 34f), delegate
			{
				OpenDesignCodePanel(exportCurrent: true);
			});
			_importCodeButton = CreateAnchoredButton(val.transform, "Import Code", new Rect(461f, 686f, 139f, 34f), delegate
			{
				OpenDesignCodePanel(exportCurrent: false);
			});
			CreateAnchoredButton(val.transform, "Undo", new Rect(314f, 728f, 90f, 34f), Undo);
			CreateAnchoredButton(val.transform, "Redo", new Rect(412f, 728f, 90f, 34f), Redo);
			_resetButton = CreateAnchoredButton(val.transform, "Reset", new Rect(510f, 728f, 90f, 34f), delegate
			{
				SaveUndo("Reset");
				DrawableSuitsPlugin.Registry.ResetSuit(_selectedSuitId);
				ClearRedoHistory("reset");
				InvalidateDecalPreview("reset");
				UpdateUiState();
			});
			_applyButton = CreateAnchoredButton(val.transform, "Apply", new Rect(314f, 768f, 90f, 34f), delegate
			{
				DrawableSuitsPlugin.Registry.ApplyEditedTexture(_selectedSuitId, _designName, broadcast: true);
			});
			_saveButton = CreateAnchoredButton(val.transform, "Save", new Rect(412f, 768f, 90f, 34f), SaveDesign);
			_savedDesignsButton = CreateAnchoredButton(val.transform, "Designs", new Rect(510f, 768f, 90f, 34f), OpenSavedDesignsPanel);
			CreateSectionDivider(val.transform, new Rect(314f, 826f, 286f, 1f));
			CreateAnchoredText(val.transform, "UndoHistoryHeader", "Undo History", 16, (FontStyle)1, (TextAnchor)3, new Rect(314f, 834f, 286f, 24f), TerminalTextColor);
			BuildUndoHistoryPanel(val.transform, new Rect(314f, 860f, 286f, 120f));
			GameObject val2 = CreateUiObject("PreviewViewport", val.transform, typeof(RectTransform), typeof(Image));
			_previewViewportRect = val2.GetComponent<RectTransform>();
			SetAnchoredRect(_previewViewportRect, new Rect(314f, 418f, 286f, 176f));
			val2.transform.SetSiblingIndex(((Object)(object)_decalListContent != (Object)null) ? (((Transform)_decalListContent).GetSiblingIndex() + 1) : val2.transform.GetSiblingIndex());
			Image component4 = val2.GetComponent<Image>();
			((Graphic)component4).color = new Color(0.015f, 0.016f, 0.018f, 1f);
			((Graphic)component4).raycastTarget = true;
			ApplyTerminalOutline(val2, TerminalOutlineColor);
			GameObject val3 = CreateUiObject("TexturePreviewImage", val2.transform, typeof(RectTransform), typeof(RotatedUvRawImage));
			RectTransform component5 = val3.GetComponent<RectTransform>();
			component5.anchorMin = Vector2.zero;
			component5.anchorMax = Vector2.one;
			component5.offsetMin = Vector2.zero;
			component5.offsetMax = Vector2.zero;
			_previewImage = val3.GetComponent<RotatedUvRawImage>();
			((RawImage)_previewImage).texture = (Texture)(object)EnsureCheckerTexture();
			((RawImage)_previewImage).uvRect = new Rect(0f, 0f, 10f, 10f);
			((Graphic)_previewImage).color = Color.white;
			((Graphic)_previewImage).raycastTarget = true;
			_uvDecalPreviewRect = CreateUiObject("UvDecalPlacementPreview", val2.transform, typeof(RectTransform), typeof(RawImage)).GetComponent<RectTransform>();
			_uvDecalPreviewRect.anchorMin = new Vector2(0f, 1f);
			_uvDecalPreviewRect.anchorMax = new Vector2(0f, 1f);
			_uvDecalPreviewRect.pivot = new Vector2(0.5f, 0.5f);
			_uvDecalPreviewRect.anchoredPosition = Vector2.zero;
			_uvDecalPreviewRect.sizeDelta = new Vector2(32f, 32f);
			_uvDecalPreviewImage = ((Component)_uvDecalPreviewRect).GetComponent<RawImage>();
			((Graphic)_uvDecalPreviewImage).color = new Color(1f, 1f, 1f, 0.62f);
			((Graphic)_uvDecalPreviewImage).raycastTarget = false;
			((Component)_uvDecalPreviewRect).gameObject.SetActive(false);
			_uvMirrorDecalPreviewRect = CreateUiObject("UvMirrorDecalPlacementPreview", val2.transform, typeof(RectTransform), typeof(RawImage)).GetComponent<RectTransform>();
			_uvMirrorDecalPreviewRect.anchorMin = new Vector2(0f, 1f);
			_uvMirrorDecalPreviewRect.anchorMax = new Vector2(0f, 1f);
			_uvMirrorDecalPreviewRect.pivot = new Vector2(0.5f, 0.5f);
			_uvMirrorDecalPreviewRect.anchoredPosition = Vector2.zero;
			_uvMirrorDecalPreviewRect.sizeDelta = new Vector2(32f, 32f);
			_uvMirrorDecalPreviewImage = ((Component)_uvMirrorDecalPreviewRect).GetComponent<RawImage>();
			((Graphic)_uvMirrorDecalPreviewImage).color = new Color(1f, 1f, 1f, 0.5f);
			((Graphic)_uvMirrorDecalPreviewImage).raycastTarget = false;
			((Component)_uvMirrorDecalPreviewRect).gameObject.SetActive(false);
			_brushIndicator = CreateUiObject("BrushIndicator", val2.transform, typeof(RectTransform), typeof(Image)).GetComponent<RectTransform>();
			_brushIndicator.sizeDelta = new Vector2(16f, 16f);
			_brushIndicatorImage = ((Component)_brushIndicator).GetComponent<Image>();
			((Graphic)_brushIndicatorImage).color = new Color(1f, 1f, 1f, 0.32f);
			((Graphic)_brushIndicatorImage).raycastTarget = false;
			((Component)_brushIndicator).gameObject.SetActive(false);
			val2.SetActive(false);
			CreateAnchoredText(val.transform, "ControllerHelp", "Controller: left stick cursor, A click, RT use, X undo, Start save.", 12, (FontStyle)0, (TextAnchor)0, new Rect(18f, 958f, 274f, 34f), TerminalMutedTextColor);
			BuildDesignCodePanel();
			BuildSavedDesignsPanel();
			BuildDecalsPanel();
			BuildStickersPanel();
			BuildPlacementEditPanel();
			_editorCanvasObject.SetActive(false);
			RefreshListButtons();
			UpdateUiState();
			RebuildSelectableNavigation();
			LogEditorControlTree(val.transform);
			DrawableSuitsDiagnostics.Info($"EditorThemeBuilt: theme=ImperiumInspiredTerminal; iconButtons=True; panelColor={((Graphic)component3).color}; accent={TerminalAccentColor}; text={TerminalTextColor}");
			float num3 = 802f;
			Rect val4 = default(Rect);
			((Rect)(ref val4))..ctor(306f, 608f, 302f, 204f);
			Rect val5 = default(Rect);
			((Rect)(ref val5))..ctor(314f, 860f, 286f, 120f);
			DrawableSuitsDiagnostics.Info($"EditorLayoutBuilt: panel={620f:0}x{1010f:0}; left={18f:0},{150f:0},{274f:0}; right={314f:0},{150f:0},{286f:0}; sections=tools:{150f:0},brush:{270f:0},color:{432f:0},placement:{150f:0},uv:{390f:0},design:{608f:0},undo:{826f:0}; textureRect={314f:0},{418f:0},{286f:0},{176f:0}; recentColorsRect={((Rect)(ref rect)).x:0},{((Rect)(ref rect)).y:0},{((Rect)(ref rect)).width:0},{((Rect)(ref rect)).height:0}; designCard={((Rect)(ref val4)).x:0},{((Rect)(ref val4)).y:0},{((Rect)(ref val4)).width:0},{((Rect)(ref val4)).height:0}; designActionBottom={num3:0}; undoRect={((Rect)(ref val5)).x:0},{((Rect)(ref val5)).y:0},{((Rect)(ref val5)).width:0},{((Rect)(ref val5)).height:0}; pairButtonW={139f:0.#}; actionButtonW={90f:0.#}; footerY={958f:0}");
			DrawableSuitsDiagnostics.Info($"BuildEditorCanvas complete. childCount={_editorCanvasObject.transform.childCount}; panelChildren={val.transform.childCount}; graphicRaycaster={(Object)(object)_editorCanvasObject.GetComponent<GraphicRaycaster>() != (Object)null}; mode=compactThirdPerson");
		}

		private void BuildDesignCodePanel()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			_designCodePanelObject = CreateUiObject("DesignCodePanel", _editorCanvasObject.transform, typeof(RectTransform), typeof(Image));
			RectTransform component = _designCodePanelObject.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			Image component2 = _designCodePanelObject.GetComponent<Image>();
			((Graphic)component2).color = new Color(0f, 0f, 0f, 0.28f);
			((Graphic)component2).raycastTarget = true;
			GameObject val = CreateUiObject("DesignCodeDialog", _designCodePanelObject.transform, typeof(RectTransform), typeof(Image));
			RectTransform component3 = val.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0.5f, 0.5f);
			component3.anchorMax = new Vector2(0.5f, 0.5f);
			component3.pivot = new Vector2(0.5f, 0.5f);
			component3.anchoredPosition = Vector2.zero;
			component3.sizeDelta = new Vector2(760f, 430f);
			Image component4 = val.GetComponent<Image>();
			((Graphic)component4).color = TerminalDialogColor;
			((Graphic)component4).raycastTarget = true;
			ApplyTerminalOutline(val, TerminalOutlineColor);
			CreateAnchoredText(val.transform, "DesignCodeTitle", "Design Code Import / Export", 22, (FontStyle)1, (TextAnchor)3, new Rect(18f, 14f, 560f, 34f), TerminalStatusColor);
			CreateAnchoredText(val.transform, "DesignCodeHelp", "Export creates a compact shareable DSUIT2 code for the current editable texture. Import accepts DSUIT2 or legacy DSUIT1 codes into the current suit only; press Save or Apply when ready.", 14, (FontStyle)0, (TextAnchor)0, new Rect(18f, 54f, 724f, 48f), TerminalTextColor);
			_designCodeInput = CreateAnchoredInputField(val.transform, "DesignCodeInput", string.Empty, new Rect(18f, 112f, 724f, 194f));
			_designCodeInput.lineType = (LineType)2;
			_designCodeInput.contentType = (ContentType)0;
			_designCodeInput.textComponent.alignment = (TextAnchor)0;
			_designCodeInput.textComponent.fontSize = 12;
			_designCodeInput.textComponent.horizontalOverflow = (HorizontalWrapMode)0;
			_designCodeInput.textComponent.verticalOverflow = (VerticalWrapMode)1;
			CreateAnchoredButton(val.transform, "Copy Current", new Rect(18f, 320f, 132f, 34f), CopyCurrentDesignCode);
			CreateAnchoredButton(val.transform, "Paste", new Rect(160f, 320f, 90f, 34f), PasteDesignCodeFromClipboard);
			CreateAnchoredButton(val.transform, "Import", new Rect(260f, 320f, 98f, 34f), ImportDesignCodeFromField);
			CreateAnchoredButton(val.transform, "Close", new Rect(644f, 320f, 98f, 34f), CloseDesignCodePanel);
			_designCodeStatusLabel = CreateAnchoredText(val.transform, "DesignCodeStatus", string.Empty, 13, (FontStyle)0, (TextAnchor)0, new Rect(18f, 366f, 724f, 46f), TerminalStatusColor);
			_designCodePanelObject.SetActive(false);
			DrawableSuitsDiagnostics.Info("DesignCodePanel built.");
		}

		private void BuildSavedDesignsPanel()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			_savedDesignsPanelObject = CreateUiObject("SavedDesignsPanel", _editorCanvasObject.transform, typeof(RectTransform), typeof(Image));
			RectTransform component = _savedDesignsPanelObject.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			Image component2 = _savedDesignsPanelObject.GetComponent<Image>();
			((Graphic)component2).color = new Color(0f, 0f, 0f, 0.28f);
			((Graphic)component2).raycastTarget = true;
			GameObject val = CreateUiObject("SavedDesignsDialog", _savedDesignsPanelObject.transform, typeof(RectTransform), typeof(Image));
			RectTransform component3 = val.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0.5f, 0.5f);
			component3.anchorMax = new Vector2(0.5f, 0.5f);
			component3.pivot = new Vector2(0.5f, 0.5f);
			component3.anchoredPosition = Vector2.zero;
			component3.sizeDelta = new Vector2(520f, 520f);
			Image component4 = val.GetComponent<Image>();
			((Graphic)component4).color = TerminalDialogColor;
			((Graphic)component4).raycastTarget = true;
			ApplyTerminalOutline(val, TerminalOutlineColor);
			CreateAnchoredText(val.transform, "SavedDesignsTitle", "Saved Designs", 22, (FontStyle)1, (TextAnchor)3, new Rect(18f, 14f, 360f, 34f), TerminalStatusColor);
			CreateAnchoredText(val.transform, "SavedDesignsHelp", "Select a saved design, then load it into the current suit. Save and Apply stay explicit.", 14, (FontStyle)0, (TextAnchor)0, new Rect(18f, 54f, 484f, 42f), TerminalTextColor);
			_designListContent = CreateAnchoredScrollList(val.transform, "DesignList", new Rect(18f, 104f, 484f, 276f));
			_loadSelectedDesignButton = CreateAnchoredButton(val.transform, "Load Selected", new Rect(18f, 394f, 124f, 34f), LoadSelectedDesign);
			_deleteSelectedDesignButton = CreateAnchoredButton(val.transform, "Delete Selected", new Rect(150f, 394f, 124f, 34f), DeleteSelectedDesign);
			CreateAnchoredButton(val.transform, "Refresh", new Rect(282f, 394f, 82f, 34f), RefreshSavedDesignsPanel);
			CreateAnchoredButton(val.transform, "Close", new Rect(404f, 394f, 98f, 34f), CloseSavedDesignsPanel);
			_savedDesignsStatusLabel = CreateAnchoredText(val.transform, "SavedDesignsStatus", string.Empty, 13, (FontStyle)0, (TextAnchor)0, new Rect(18f, 442f, 484f, 48f), TerminalStatusColor);
			_savedDesignsPanelObject.SetActive(false);
			DrawableSuitsDiagnostics.Info("SavedDesignsPanel built.");
		}

		private void BuildDecalsPanel()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			_decalsPanelObject = CreateUiObject("DecalsPanel", _editorCanvasObject.transform, typeof(RectTransform), typeof(Image));
			RectTransform component = _decalsPanelObject.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			Image component2 = _decalsPanelObject.GetComponent<Image>();
			((Graphic)component2).color = new Color(0f, 0f, 0f, 0.28f);
			((Graphic)component2).raycastTarget = true;
			GameObject val = CreateUiObject("DecalsDialog", _decalsPanelObject.transform, typeof(RectTransform), typeof(Image));
			RectTransform component3 = val.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0.5f, 0.5f);
			component3.anchorMax = new Vector2(0.5f, 0.5f);
			component3.pivot = new Vector2(0.5f, 0.5f);
			component3.anchoredPosition = Vector2.zero;
			component3.sizeDelta = new Vector2(520f, 520f);
			Image component4 = val.GetComponent<Image>();
			((Graphic)component4).color = TerminalDialogColor;
			((Graphic)component4).raycastTarget = true;
			ApplyTerminalOutline(val, TerminalOutlineColor);
			CreateAnchoredText(val.transform, "DecalsTitle", "Decals", 22, (FontStyle)1, (TextAnchor)3, new Rect(18f, 14f, 360f, 34f), TerminalStatusColor);
			CreateAnchoredText(val.transform, "DecalsHelp", "Select a decal from the folder. Use Copy Folder Path, add PNG/JPG files manually, then Refresh.", 14, (FontStyle)0, (TextAnchor)0, new Rect(18f, 54f, 484f, 42f), TerminalTextColor);
			_decalListContent = CreateAnchoredScrollList(val.transform, "DecalList", new Rect(18f, 104f, 484f, 276f));
			_deleteSelectedDecalButton = CreateAnchoredButton(val.transform, "Delete Selected", new Rect(18f, 394f, 124f, 34f), DeleteSelectedDecal);
			_addDecalButton = CreateAnchoredButton(val.transform, "Copy Folder Path", new Rect(150f, 394f, 142f, 34f), CopyDecalsFolderPath);
			CreateAnchoredButton(val.transform, "Refresh", new Rect(300f, 394f, 82f, 34f), RefreshDecalsPanel);
			CreateAnchoredButton(val.transform, "Close", new Rect(404f, 394f, 98f, 34f), CloseDecalsPanel);
			_decalsStatusLabel = CreateAnchoredText(val.transform, "DecalsStatus", string.Empty, 13, (FontStyle)0, (TextAnchor)0, new Rect(18f, 442f, 484f, 48f), TerminalStatusColor);
			_decalsPanelObject.SetActive(false);
			DrawableSuitsDiagnostics.Info("DecalsPanel built.");
		}

		private void BuildStickersPanel()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: 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_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			_stickerPanelShapeButtons.Clear();
			_stickersPanelObject = CreateUiObject("StickersPanel", _editorCanvasObject.transform, typeof(RectTransform), typeof(Image));
			RectTransform component = _stickersPanelObject.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			Image component2 = _stickersPanelObject.GetComponent<Image>();
			((Graphic)component2).color = new Color(0f, 0f, 0f, 0.28f);
			((Graphic)component2).raycastTarget = true;
			GameObject val = CreateUiObject("StickersDialog", _stickersPanelObject.transform, typeof(RectTransform), typeof(Image));
			RectTransform component3 = val.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0.5f, 0.5f);
			component3.anchorMax = new Vector2(0.5f, 0.5f);
			component3.pivot = new Vector2(0.5f, 0.5f);
			component3.anchoredPosition = Vector2.zero;
			component3.sizeDelta = new Vector2(520f, 420f);
			Image component4 = val.GetComponent<Image>();
			((Graphic)component4).color = TerminalDialogColor;
			((Graphic)component4).raycastTarget = true;
			ApplyTerminalOutline(val, TerminalOutlineColor);
			CreateAnchoredText(val.transform, "StickersTitle", "Stickers", 22, (FontStyle)1, (TextAnchor)3, new Rect(18f, 14f, 360f, 34f), TerminalStatusColor);
			CreateAnchoredText(val.transform, "StickersHelp", "Choose a built-in sticker shape. Stickers use the current brush color and opacity, then bake into the suit texture when stamped.", 14, (FontStyle)0, (TextAnchor)0, new Rect(18f, 54f, 484f, 42f), TerminalTextColor);
			StickerShape[] array = (StickerShape[])Enum.GetValues(typeof(StickerShape));
			Rect rect = default(Rect);
			for (int i = 0; i < array.Length; i++)
			{
				StickerShape shape = array[i];
				int num = i % 3;
				int num2 = i / 3;
				((Rect)(ref rect))..ctor(18f + (float)num * 162f, 108f + (float)num2 * 46f, 150f, 34f);
				Button item = CreateAnchoredButton(val.transform, StickerShapeDisplayName(shape), rect, delegate
				{
					SelectStickerShape(shape);
				});
				_stickerPanelShapeButtons.Add(item);
			}
			CreateAnchoredButton(val.transform, "Close", new Rect(404f, 346f, 98f, 34f), CloseStickersPanel);
			_stickersStatusLabel = CreateAnchoredText(val.transform, "StickersStatus", string.Empty, 13, (FontStyle)0, (TextAnchor)0, new Rect(18f, 344f, 380f, 48f), TerminalStatusColor);
			_stickersPanelObject.SetActive(false);
			DrawableSuitsDiagnostics.Info("StickersPanel built.");
		}

		private void BuildPlacementEditPanel()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0407: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0440: Unknown result type (might be due to invalid IL or missing references)
			//IL_0445: Unknown result type (might be due to invalid IL or missing references)
			//IL_0483: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_050a: Unknown result type (might be due to invalid IL or missing references)
			//IL_054e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0553: Unknown result type (might be due to invalid IL or missing references)
			//IL_0591: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0618: Unknown result type (might be due to invalid IL or missing references)
			//IL_065b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0660: Unknown result type (might be due to invalid IL or missing references)
			//IL_0694: Unknown result type (might be due to invalid IL or missing references)
			//IL_0699: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_071b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0720: Unknown result type (might be due to invalid IL or missing references)
			//IL_075e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0799: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0817: Unknown result type (might be due to invalid IL or missing references)
			//IL_081c: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0934: Unknown result type (might be due to invalid IL or missing references)
			//IL_099e: Unknown result type (might be due to invalid IL or missing references)
			//IL_09d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a14: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a19: Unknown result type (might be due to invalid IL or missing references)
			_placementEditPanelObject = CreateUiObject("PlacementEditPanel", _editorCanvasObject.transform, typeof(RectTransform), typeof(Image));
			RectTransform component = _placementEditPanelObject.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			Image component2 = _placementEditPanelObject.GetComponent<Image>();
			((Graphic)component2).color = new Color(0f, 0f, 0f, 0.28f);
			((Graphic)component2).raycastTarget = true;
			GameObject val = CreateUiObject("PlacementEditDialog", _placementEditPanelObject.transform, typeof(RectTransform), typeof(Image));
			RectTransform component3 = val.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0.5f, 0.5f);
			component3.anchorMax = new Vector2(0.5f, 0.5f);
			component3.pivot = new Vector2(0.5f, 0.5f);
			component3.anchoredPosition = Vector2.zero;
			component3.sizeDelta = new Vector2(720f, 640f);
			Image component4 = val.GetComponent<Image>();
			((Graphic)component4).color = TerminalDialogColor;
			((Graphic)component4).raycastTarget = true;
			ApplyTerminalOutline(val, TerminalOutlineColor);
			_placementEditTitleLabel = CreateAnchoredText(val.transform, "PlacementEditTitle", "Edit Placement", 22, (FontStyle)1, (TextAnchor)3, new Rect(18f, 14f, 360f, 34f), TerminalStatusColor);
			_placementEditSourceLabel = CreateAnchoredText(val.transform, "PlacementEditSource", string.Empty, 13, (FontStyle)0, (TextAnchor)0, new Rect(18f, 50f, 360f, 42f), TerminalTextColor);
			GameObject val2 = CreateUiObject("PlacementEditPreviewFrame", val.transform, typeof(RectTransform), typeof(Image));
			_placementEditPreviewFrameRect = val2.GetComponent<RectTransform>();
			SetAnchoredRect(_placementEditPreviewFrameRect, new Rect(520f, 50f, 160f, 160f));
			((Graphic)val2.GetComponent<Image>()).color = TerminalInputColor;
			ApplyTerminalOutline(val2, TerminalOutlineColor);
			GameObject val3 = CreateUiObject("PlacementEditPreviewChecker", val2.transform, typeof(RectTransform), typeof(RawImage));
			RectTransform component5 = val3.GetComponent<RectTransform>();
			component5.anchorMin = Vector2.zero;
			component5.anchorMax = Vector2.one;
			component5.offsetMin = new Vector2(8f, 8f);
			component5.offsetMax = new Vector2(-8f, -8f);
			_placementEditPreviewBackingImage = val3.GetComponent<RawImage>();
			_placementEditPreviewBackingImage.texture = (Texture)(object)GetPlacementEditCheckerTexture();
			((Graphic)_placementEditPreviewBackingImage).color = Color.white;
			((Graphic)_placementEditPreviewBackingImage).raycastTarget = false;
			GameObject val4 = CreateUiObject("PlacementEditPreview", val2.transform, typeof(RectTransform), typeof(RawImage));
			_placementEditPreviewRect = val4.GetComponent<RectTransform>();
			_placementEditPreviewRect.anchorMin = new Vector2(0.5f, 0.5f);
			_placementEditPreviewRect.anchorMax = new Vector2(0.5f, 0.5f);
			_placementEditPreviewRect.pivot = new Vector2(0.5f, 0.5f);
			_placementEditPreviewRect.anchoredPosition = Vector2.zero;
			_placementEditPreviewRect.sizeDelta = new Vector2(144f, 144f);
			_placementEditPreviewImage = val4.GetComponent<RawImage>();
			((Graphic)_placementEditPreviewImage).color = Color.white;
			((Graphic)_placementEditPreviewImage).raycastTarget = false;
			CreateAnchoredText(val.transform, "PlacementCropHeader", "Crop", 16, (FontStyle)1, (TextAnchor)3, new Rect(18f, 104f, 250f, 24f), TerminalStatusColor);
			_placementEditCropLeftLabel = CreateAnchoredText(val.transform, "PlacementCropLeftLabel", string.Empty, 13, (FontStyle)0, (TextAnchor)3, new Rect(18f, 136f, 88f, 22f), TerminalTextColor);
			_placementEditCropLeftSlider = CreateAnchoredSlider(val.transform, "PlacementCropLeft", 0f, 0.95f, 0f, new Rect(112f, 136f, 250f, 22f), delegate(float cropLeft)
			{
				PlacementEditState placementEditState = GetPlacementEditState(_activePlacementEditTarget);
				if (placementEditState != null)
				{
					placementEditState.CropLeft = cropLeft;
					OnPlacementEditChanged("crop left");
				}
			});
			_placementEditCropRightLabel = CreateAnchoredText(val.transform, "PlacementCropRightLabel", string.Empty, 13, (FontStyle)0, (TextAnchor)3, new Rect(18f, 166f, 88f, 22f), TerminalTextColor);
			_placementEditCropRightSlider = CreateAnchoredSlider(val.transform, "PlacementCropRight", 0f, 0.95f, 0f, new Rect(112f, 166f, 250f, 22f), delegate(float cropRight)
			{
				PlacementEditState placementEditState = GetPlacementEditState(_activePlacementEditTarget);
				if (placementEditState != null)
				{
					placementEditState.CropRight = cropRight;
					OnPlacementEditChanged("crop right");
				}
			});
			_placementEditCropBottomLabel = CreateAnchoredText(val.transform, "PlacementCropBottomLabel", string.Empty, 13, (FontStyle)0, (TextAnchor)3, new Rect(18f, 196f, 88f, 22f), TerminalTextColor);
			_placementEditCropBottomSlider = CreateAnchoredSlider(val.transform, "PlacementCropBottom", 0f, 0.95f, 0f, new Rect(112f, 196f, 250f, 22f), delegate(float cropBottom)
			{
				PlacementEditState placementEditState = GetPlacementEditState(_activePlacementEditTarget);
				if (placementEditState != null)
				{
					placementEditState.CropBottom = cropBottom;
					OnPlacementEditChanged("crop bottom");
				}
			});
			_placementEditCropTopLabel = CreateAnchoredText(val.transform, "PlacementCropTopLabel", string.Empty, 13, (FontStyle)0, (TextAnchor)3, new Rect(18f, 226f, 88f, 22f), TerminalTextColor);
			_placementEditCropTopSlider = CreateAnchoredSlider(val.transform, "PlacementCropTop", 0f, 0.95f, 0f, new Rect(112f, 226f, 250f, 22f), delegate(float cropTop)
			{
				PlacementEditState placementEditState = GetPlacementEditState(_activePlacementEditTarget);
				if (placementEditState != null)
				{
					placementEditState.CropTop = cropTop;
					OnPlacementEditChanged("crop top");
				}
			});
			CreateAnchoredText(val.transform, "PlacementTransformHeader", "Shape", 16, (FontStyle)1, (TextAnchor)3, new Rect(18f, 268f, 250f, 24f), TerminalStatusColor);
			_placementEditStretchXLabel = CreateAnchoredText(val.transform, "PlacementStretchXLabel", string.Empty, 13, (FontStyle)0, (TextAnchor)3, new Rect(18f, 300f, 88f, 22f), TerminalTextColor);
			_placementEditStretchXSlider = CreateAnchoredSlider(val.transform, "PlacementStretchX", 0.25f, 3f, 1f, new Rect(112f, 300f, 250f, 22f), delegate(float stretchX)
			{
				PlacementEditState placementEditState = GetPlacementEditState(_activePlacementEditTarget);
				if (placementEditState != null)
				{
					placementEditState.StretchX = stretchX;
					OnPlacementEditChanged("stretch x");
				}
			});
			_placementEditStretchYLabel = CreateAnchoredText(val.transform, "PlacementStretchYLabel", string.Empty, 13, (FontStyle)0, (TextAnchor)3, new Rect(18f, 330f, 88f, 22f), TerminalTextColor);
			_placementEditStretchYSlider = CreateAnchoredSlider(val.transform, "PlacementStretchY", 0.25f, 3f, 1f, new Rect(112f, 330f, 250f, 22f), delegate(float stretchY)
			{
				PlacementEditState placementEditState = GetPlacementEditState(_activePlacementEditTarget);
				if (placementEditState != null)
				{
					placementEditState.StretchY = stretchY;
					OnPlacementEditChanged("stretch y");
				}
			});
			_placementEditFlipXButton = CreateAnchoredButton(val.transform, "Flip X", new Rect(392f, 298f, 90f, 34f), TogglePlacementEditFlipX);
			_placementEditFlipYButton = CreateAnchoredButton(val.transform, "Flip Y", new Rect(492f, 298f, 90f, 34f), TogglePlacementEditFlipY);
			CreateAnchoredText(val.transform, "PlacementFilterHeader", "Filters", 16, (FontStyle)1, (TextAnchor)3, new Rect(18f, 374f, 250f, 24f), TerminalStatusColor);
			_placementEditFilterValueLabels.Clear();
			_placementEditFilterSliders.Clear();
			for (int num = 0; num < PlacementFilterRows.Length; num++)
			{
				PlacementFilter placementFilter = PlacementFilterRows[num];
				float num2 = 402f + (float)num * 24f;
				CreateAnchoredText(val.transform, $"PlacementFilter{placementFilter}Label", PlacementFilterDisplayName(placementFilter), 12, (FontStyle)0, (TextAnchor)3, new Rect(18f, num2, 92f, 20f), TerminalTextColor);
				Text value = CreateAnchoredText(val.transform, $"PlacementFilter{placementFilter}Value", "0%", 12, (FontStyle)0, (TextAnchor)3, new Rect(350f, num2, 56f, 20f), TerminalMutedTextColor);
				PlacementFilter capturedFilter = placementFilter;
				DrawableSliderControl value2 = CreateAnchoredSlider(val.transform, $"PlacementFilter{placementFilter}", 0f, 1f, 0f, new Rect(112f, num2, 230f, 20f), delegate(float amount)
				{
					PlacementEditState placementEditState = GetPlacementEditState(_activePlacementEditTarget);
					if (placementEditState != null)
					{
						placementEditState.SetFilterAmount(capturedFilter, amount);
						OnPlacementEditChanged($"filter {capturedFilter}");
					}
				});
				_placementEditFilterValueLabels[placementFilter] = value;
				_placementEditFilterSliders[placementFilter] = value2;
			}
			CreateAnchoredButton(val.transform, "Reset Edits", new Rect(18f, 586f, 126f, 34f), ResetActivePlacementEdit);
			CreateAnchoredButton(val.transform, "Close", new Rect(594f, 586f, 90f, 34f), ClosePlacementEditPanel);
			_placementEditStatusLabel = CreateAnchoredText(val.transform, "PlacementEditStatus", string.Empty, 13, (FontStyle)0, (TextAnchor)0, new Rect(156f, 584f, 426f, 44f), TerminalStatusColor);
			_placementEditPanelObject.SetActive(false);
			DrawableSuitsDiagnostics.Info("PlacementEditPanel built.");
		}

		private void EnsureCursorCanvas()
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (!((Object)(object)_cursorCanvasObject != (Object)null) || !((Object)(object)_cursorCanvasRect != (Object)null) || !((Object)(object)_cursorMarker != (Object)null) || !((Object)(object)_cursorBackImage != (Object)null) || !((Object)(object)_cursorImage != (Object)null))
			{
				if ((Object)(object)_cursorCanvasObject != (Object)null)
				{
					Object.Destroy((Object)(object)_cursorCanvasObject);
				}
				_cursorCanvasObject = new GameObject("DrawableSuitsCursorCanvas", new Type[2]
				{
					typeof(RectTransform),
					typeof(Canvas)
				});
				Object.DontDestroyOnLoad((Object)(object)_cursorCanvasObject);
				_cursorCanvasRect = _cursorCanvasObject.GetComponent<RectTransform>();
				_cursorCanvasRect.anchorMin = Vector2.zero;
				_cursorCanvasRect.anchorMax = Vector2.one;
				_cursorCanvasRect.offsetMin = Vector2.zero;
				_cursorCanvasRect.offsetMax = Vector2.zero;
				Canvas component = _cursorCanvasObject.GetComponent<Canvas>();
				component.renderMode = (RenderMode)0;
				component.overrideSorting = true;
				component.sortingOrder = 32767;
				if (component.sortingOrder != 32767 || component.sortingOrder <= 32760)
				{
					DrawableSuitsDiagnostics.Warn($"Cursor canvas sorting order invalid after assignment. requested=32767; actual={component.sortingOrder}; editorOrder={32760}");
				}
				CreateDynamicCursorMarker(_cursorCanvasObject.transform);
				_cursorCanvasObject.SetActive(false);
				LogCursorCanvasState("created");
			}
		}

		private void CreateDynamicCursorMarker(Transform parent)
		{
			//IL_0031: 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_005b: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUiObject("DrawableSuitsCursor", parent, typeof(RectTransform));
			_cursorMarker = val.GetComponent<RectTransform>();
			_cursorMarker.anchorMin = Vector2.zero;
			_cursorMarker.anchorMax = Vector2.zero;
			_cursorMarker.pivot = new Vector2(0.5f, 0.5f);
			_cursorMarker.sizeDelta = new Vector2(17f, 17f);
			_cursorBackRect = CreateUiObject("CursorBack", (Transform)(object)_cursorMarker, typeof(RectTransform), typeof(Image)).GetComponent<RectTransform>();
			_cursorBackRect.anchorMin = new Vector2(0.5f, 0.5f);
			_cursorBackRect.anchorMax = new Vector2(0.5f, 0.5f);
			_cursorBackRect.pivot = new Vector2(0.5f, 0.5f);
			_cursorBackRect.anchoredPosition = Vector2.zero;
			_cursorBackRect.sizeDelta = new Vector2(15f, 15f);
			_cursorBackImage = ((Component)_cursorBackRect).GetComponent<Image>();
			_cursorBackImage.sprite = EnsureCursorDotSprite();
			((Graphic)_cursorBackImage).color = new Color(0f, 0f, 0f, 0.85f);
			((Graphic)_cursorBackImage).raycastTarget = false;
			_cursorBackImage.preserveAspect = true;
			_cursorBackImage.type = (Type)0;
			_cursorFrontRect = CreateUiObject("CursorFront", (Transform)(object)_cursorMarker, typeof(RectTransform), typeof(Image)).GetComponent<RectTransform>();
			_cursorFrontRect.anchorMin = new Vector2(0.5f, 0.5f);
			_cursorFrontRect.anchorMax = new Vector2(0.5f, 0.5f);
			_cursorFrontRect.pivot = new Vector2(0.5f, 0.5f);
			_cursorFrontRect.anchoredPosition = Vector2.zero;
			_cursorFrontRect.sizeDelta = new Vector2(9f, 9f);
			_cursorImage = ((Component)_cursorFrontRect).GetComponent<Image>();
			_cursorImage.sprite = EnsureCursorDotSprite();
			((Graphic)_cursorImage).color = Color.white;
			((Graphic)_cursorImage).raycastTarget = false;
			_cursorImage.preserveAspect = true;
			_cursorImage.type = (Type)0;
		}

		private void SetCursorCanvasVisible(bool visible, string context)
		{
			if (visible)
			{
				DestroyLegacyCursorCanvas("ignored legacy show request: " + context);
			}
			else
			{
				DestroyLegacyCursorCanvas("legacy hide request: " + context);
			}
		}

		private static GameObject CreateUiObject(string name, Transform parent, params Type[] components)
		{
			//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_0015: Expected O, but got Unknown
			GameObject val = new GameObject(name, components);
			val.transform.SetParent(parent, false);
			return val;
		}

		private static void SetAnchoredRect(RectTransform rectTransform, Rect rect)
		{
			//IL_000b: 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_0035: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			rectTransform.anchorMin = new Vector2(0f, 1f);
			rectTransform.anchorMax = new Vector2(0f, 1f);
			rectTransform.pivot = new Vector2(0f, 1f);
			rectTransform.anchoredPosition = new Vector2(((Rect)(ref rect)).x, 0f - ((Rect)(ref rect)).y);
			rectTransform.sizeDelta = new Vector2(((Rect)(ref rect)).width, ((Rect)(ref rect)).height);
		}

		private static Text CreateAnchoredText(Transform parent, string name, string text, int fontSize, FontStyle style, TextAnchor alignment, Rect rect, Color color)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: 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)
			GameObject obj = CreateUiObject(name, parent, typeof(RectTransform), typeof(Text));
			SetAnchoredRect(obj.GetComponent<RectTransform>(), rect);
			Text component = obj.GetComponent<Text>();
			component.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			component.text = text;
			component.fontSize = fontSize;
			component.fontStyle = style;
			component.alignment = alignment;
			((Graphic)component).color = color;
			component.horizontalOverflow = (HorizontalWrapMode)0;
			component.verticalOverflow = (VerticalWrapMode)0;
			component.supportRichText = false;
			((Graphic)component).raycastTarget = false;
			return component;
		}

		private static void CreateSectionDivider(Transform parent, Rect rect)
		{
			//IL_0031: 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)
			GameObject obj = CreateUiObject("TerminalDivider", parent, typeof(RectTransform), typeof(Image));
			SetAnchoredRect(obj.GetComponent<RectTransform>(), rect);
			Image component = obj.GetComponent<Image>();
			((Graphic)component).color = new Color(TerminalAccentColor.r, TerminalAccentColor.g, TerminalAccentColor.b, 0.45f);
			((Graphic)component).raycastTarget = false;
		}

		private static void CreateSectionCard(Transform parent, Rect rect)
		{
			//IL_0031: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreateUiObject("TerminalSectionCard", parent, typeof(RectTransform), typeof(Image));
			SetAnchoredRect(obj.GetComponent<RectTransform>(), rect);
			Image component = obj.GetComponent<Image>();
			((Graphic)component).color = new Color(TerminalCardColor.r, TerminalCardColor.g, TerminalCardColor.b, 0.22f);
			((Graphic)component).raycastTarget = false;
			ApplyTerminalOutline(obj, new Color(TerminalOutlineColor.r, TerminalOutlineColor.g, TerminalOutlineColor.b, 0.32f));
		}

		private static void ApplyTerminalOutline(GameObject go, Color color)
		{
			//IL_001b: 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)
			if (!((Object)(object)go == (Object)null))
			{
				Outline obj = go.GetComponent<Outline>() ?? go.AddComponent<Outline>();
				((Shadow)obj).effectColor = color;
				((Shadow)obj).effectDistance = new Vector2(1.25f, -1.25f);
				((Shadow)obj).useGraphicAlpha = true;
			}
		}

		private static Text CreateAnchoredValueLabel(Transform parent, string name, string text, Rect rect)
		{
			//IL_002d: 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_004b: 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)
			GameObject obj = CreateUiObject(name, parent, typeof(RectTransform), typeof(Image));
			SetAnchoredRect(obj.GetComponent<RectTransform>(), rect);
			Image component = obj.GetComponent<Image>();
			((Graphic)component).color = TerminalInputColor;
			((Graphic)component).raycastTarget = false;
			ApplyTerminalOutline(obj, TerminalOutlineColor);
			Text obj2 = CreateAnchoredText(obj.transform, "Label", text, 14, (FontStyle)0, (TextAnchor)4, new Rect(8f, 0f, ((Rect)(ref rect)).width - 16f, ((Rect)(ref rect)).height), TerminalTextColor);
			obj2.horizontalOverflow = (HorizontalWrapMode)0;
			obj2.verticalOverflow = (VerticalWrapMode)0;
			return obj2;
		}

		private static Button CreateAnchoredIconButton(Transform parent, string toolName, ToolIconKind iconKind, Rect rect, Action onClick)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: 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_00d1: 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_00ea: 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_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUiObject(toolName + "IconButton", parent, typeof(RectTransform), typeof(Image), typeof(Button));
			SetAnchoredRect(val.GetComponent<RectTransform>(), rect);
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = TerminalButtonColor;
			ApplyTerminalOutline(val, TerminalOutlineColor);
			Button component2 = val.GetComponent<Button>();
			((Selectable)component2).targetGraphic = (Graphic)(object)component;
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				onClick?.Invoke();
				ClearSelectedNormalButton();
			});
			ColorBlock colors = ((Selectable)component2).colors;
			((ColorBlock)(ref colors)).normalColor = TerminalButtonColor;
			((ColorBlock)(ref colors)).highlightedColor = new Color(0.2f, 0.02f, 0.018f, 1f);
			((ColorBlock)(ref colors)).pressedColor = TerminalButtonPressedColor;
			((ColorBlock)(ref colors)).selectedColor = ((ColorBlock)(ref colors)).normalColor;
			((Selectable)component2).colors = colors;
			GameObject val2 = CreateUiObject("Icon", val.transform, typeof(RectTransform));
			RectTransform component3 = val2.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0.5f, 0.5f);
			component3.anchorMax = new Vector2(0.5f, 0.5f);
			component3.pivot = new Vector2(0.5f, 0.5f);
			component3.anchoredPosition = Vector2.zero;
			component3.sizeDelta = new Vector2(28f, 28f);
			Texture2D val3 = LoadToolIconTexture(iconKind);
			if ((Object)(object)val3 != (Object)null)
			{
				RawImage obj = val2.AddComponent<RawImage>();
				obj.texture = (Texture)(object)val3;
				((Graphic)obj).color = TerminalTextColor;
				((Graphic)obj).raycastTarget = false;
				DrawableSuitsDiagnostics.Info($"IconButtonBuilt: name={toolName}; icon={iconKind}; source=EmbeddedPng; texture={((Texture)val3).width}x{((Texture)val3).height}; rect={rect}");
			}
			else
			{
				val2.AddComponent<DrawableToolIconGraphic>().Configure(iconKind, TerminalTextColor);
				DrawableSuitsDiagnostics.Warn($"IconButtonBuilt: name={toolName}; icon={iconKind}; source=ProceduralFallback; rect={rect}");
			}
			return component2;
		}

		private static Texture2D LoadToolIconTexture(ToolIconKind iconKind)
		{
			//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_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Expected O, but got Unknown
			if (ToolIconTextureCache.TryGetValue(iconKind, out var value))
			{
				return value;
			}
			string text = ToolIconFileName(iconKind);
			string text2 = "DrawableSuits.Assets.ToolIcons." + text;
			Assembly assembly = typeof(SuitEditorController).Assembly;
			string text3 = text2;
			Stream manifestResourceStream = assembly.GetManifestResourceStream(text3);
			if (manifestResourceStream == null)
			{
				string[] manifestResourceNames = assembly.GetManifestResourceNames();
				foreach (string text4 in manifestResourceNames)
				{
					if (text4.EndsWith(".Assets.ToolIcons." + text, StringComparison.OrdinalIgnoreCase))
					{
						text3 = text4;
						manifestResourceStream = assembly.GetManifestResourceStream(text4);
						break;
					}
				}
			}
			if (manifestResourceStream == null)
			{
				DrawableSuitsDiagnostics.Warn($"ToolIconAssetFallback: icon={iconKind}; requestedResource={text2}; reason=resource not found");
				ToolIconTextureCache[iconKind] = null;
				return null;
			}
			using (manifestResourceStream)
			{
				byte[] array = new byte[manifestResourceStream.Length];
				int num;
				for (int j = 0; j < array.Length; j += num)
				{
					num = manifestResourceStream.Read(array, j, array.Length - j);
					if (num <= 0)
					{
						break;
					}
				}
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false)
				{
					name = $"DrawableSuitsToolIcon_{iconKind}",
					filterMode = (FilterMode)1,
					wrapMode = (TextureWrapMode)1,
					hideFlags = (HideFlags)61
				};
				if (!ImageConversion.LoadImage(val, array, false))
				{
					Object.Destroy((Object)(object)val);
					DrawableSuitsDiagnostics.Warn($"ToolIconAssetFallback: icon={iconKind}; resource={text3}; bytes={array.Length}; reason=LoadImage failed");
					ToolIconTextureCache[iconKind] = null;
					return null;
				}
				ToolIconTextureCache[iconKind] = val;
				DrawableSuitsDiagnostics.Info($"ToolIconAssetLoaded: icon={iconKind}; resource={text3}; texture={((Texture)val).width}x{((Texture)val).height}; bytes={array.Length}");
				return val;
			}
		}

		private static string ToolIconFileName(ToolIconKind iconKind)
		{
			return iconKind switch
			{
				ToolIconKind.Paint => "paint.png", 
				ToolIconKind.Erase => "erase.png", 
				ToolIconKind.Fill => "fill.png", 
				ToolIconKind.Decal => "decal.png", 
				ToolIconKind.Text => "text.png", 
				ToolIconKind.Eyedropper => "eyedropper.png", 
				ToolIconKind.Mirror => "mirror.png", 
				ToolIconKind.Sticker => "sticker.png", 
				_ => iconKind.ToString().ToLowerInvariant() + ".png", 
			};
		}

		private static Button CreateAnchoredButton(Transform parent, string text, Rect rect, Action onClick)
		{
			//IL_0051: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: 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_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: 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)
			GameObject obj = CreateUiObject(text + "Button", parent, typeof(RectTransform), typeof(Image), typeof(Button));
			SetAnchoredRect(obj.GetComponent<RectTransform>(), rect);
			Image component = obj.GetComponent<Image>();
			((Graphic)component).color = TerminalButtonColor;
			ApplyTerminalOutline(obj, TerminalOutlineColor);
			Button component2 = obj.GetComponent<Button>();
			((Selectable)component2).targetGraphic = (Graphic)(object)component;
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				onClick?.Invoke();
				ClearSelectedNormalButton();
			});
			ColorBlock colors = ((Selectable)component2).colors;
			((ColorBlock)(ref colors)).normalColor = ((Graphic)component).color;
			((ColorBlock)(ref colors)).highlightedColor = ((ColorBlock)(ref colors)).normalColor;
			((ColorBlock)(ref colors)).pressedColor = TerminalButtonPressedColor;
			((ColorBlock)(ref colors)).selectedColor = ((ColorBlock)(ref colors)).normalColor;
			((Selectable)component2).colors = colors;
			RectTransform component3 = ((Component)CreateAnchoredText(obj.transform, "Label", text, 15, (FontStyle)0, (TextAnchor)4, new Rect(0f, 0f, ((Rect)(ref rect)).width, ((Rect)(ref rect)).height), TerminalTextColor)).GetComponent<RectTransform>();
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			component3.pivot = new Vector2(0.5f, 0.5f);
			component3.anchoredPosition = Vector2.zero;
			component3.offsetMin = Vector2.zero;
			component3.offsetMax = Vector2.zero;
			return component2;
		}

		private void BuildRecentColorSwatches(Transform parent, Rect rect)
		{
			//IL_0114: 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_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected O, but got Unknown
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			_recentColorButtons.Clear();
			_recentColorImages.Clear();
			float num = (((Rect)(ref rect)).width - 180f) / 5f;
			num = Mathf.Clamp(num, 8f, 20f);
			float num2 = 180f + 5f * num;
			float num3 = ((Rect)(ref rect)).x + Mathf.Max(0f, (((Rect)(ref rect)).width - num2) * 0.5f);
			for (int i = 0; i < 12; i++)
			{
				int num4 = i / 6;
				int num5 = i % 6;
				int slot = i;
				float num6 = num3 + (float)num5 * (30f + num);
				float num7 = ((Rect)(ref rect)).y + (float)num4 * 38f;
				GameObject obj = CreateUiObject($"RecentColor{slot + 1}", parent, typeof(RectTransform), typeof(Image), typeof(Button));
				SetAnchoredRect(obj.GetComponent<RectTransform>(), new Rect(num6, num7, 30f, 30f));
				Image component = obj.GetComponent<Image>();
				((Graphic)component).color = TerminalInputColor;
				((Graphic)component).raycastTarget = true;
				Button component2 = obj.GetComponent<Button>();
				((Selectable)component2).targetGraphic = (Graphic)(object)component;
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					SelectRecentColor(slot);
					ClearSelectedNormalButton();
				});
				ColorBlock colors = ((Selectable)component2).colors;
				((ColorBlock)(ref colors)).normalColor = Color.white;
				((ColorBlock)(ref colors)).highlightedColor = new Color(1f, 1f, 1f, 0.92f);
				((ColorBlock)(ref colors)).pressedColor = new Color(0.78f, 0.78f, 0.78f, 1f);
				((ColorBlock)(ref colors)).selectedColor = ((ColorBlock)(ref colors)).normalColor;
				((Selectable)component2).colors = colors;
				_recentColorButtons.Add(component2);
				_recentColorImages.Add(component);
			}
			UpdateRecentColorSwatches();
		}

		private void BuildUndoHistoryPanel(Transform parent, Rect rect)
		{
			//IL_003d: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			_undoHistoryRows.Clear();
			GameObject val = CreateUiObject("UndoHistoryPanel", parent, typeof(RectTransform), typeof(Image));
			SetAnchoredRect(val.GetComponent<RectTransform>(), rect);
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = TerminalCardColor;
			((Graphic)component).raycastTarget = false;
			ApplyTerminalOutline(val, TerminalOutlineColor);
			_undoHistoryEmptyLabel = CreateAnchoredText(val.transform, "UndoHistoryEmpty", "No undo history", 13, (FontStyle)0, (TextAnchor)3, new Rect(8f, 6f, ((Rect)(ref rect)).width - 16f, 22f), TerminalMutedTextColor);
			for (int i = 0; i < 4; i++)
			{
				GameObject val2 = CreateUiObject($"UndoHistoryRow{i + 1}", val.transform, typeof(RectTransform), typeof(Image), typeof(Button));
				SetAnchoredRect(val2.GetComponent<RectTransform>(), new Rect(6f, 6f + (float)i * 18f, ((Rect)(ref rect)).width - 12f, 16f));
				Image component2 = val2.GetComponent<Image>();
				((Graphic)component2).color = TerminalInputColor;
				((Graphic)component2).raycastTarget = true;
				Button component3 = val2.GetComponent<Button>();
				((Selectable)component3).targetGraphic = (Graphic)(object)component2;
				((UnityEventBase)component3.onClick).RemoveAllListeners();
				ApplyNormalListButtonStyle(component3);
				Text label = CreateAnchoredText(val2.transform, "Label", string.Empty, 12, (FontStyle)0, (TextAnchor)3, new Rect(6f, 0f, ((Rect)(ref rect)).width - 24f, 16f), TerminalTextColor);
				_undoHistoryRows.Add(new UndoHistoryRow
				{
					GameObject = val2,
					Button = component3,
					Image = component2,
					Label = label,
					Index = -1
				});
			}
			_undoHistorySelectionLabel = CreateAnchoredText(val.transform, "UndoHistorySelection", "Select a row first.", 10, (FontStyle)0, (TextAnchor)3, new Rect(8f, 76f, ((Rect)(ref rect)).width - 16f, 12f), TerminalMutedTextColor);
			_undoToSelectedButton = CreateAnchoredButton(val.transform, "Undo Selected", new Rect(6f, 92f, 132f, 22f), UndoToSelectedHistory);
			_clearUndoHistoryButton = CreateAnchoredButton(val.transform, "Clear History", new Rect(146f, 92f, ((Rect)(ref rect)).width - 152f, 22f), ClearUndoHistoryByUser);
			UpdateUndoHistoryUi();
		}

		private void BuildBrushShapeMenu(Transform parent, Rect rect)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			_brushShapeOptionButtons.Clear();
			_brushShapeMenuObject = CreateUiObject("BrushShapeDropdown", parent, typeof(RectTransform), typeof(Image));
			SetAnchoredRect(_brushShapeMenuObject.GetComponent<RectTransform>(), rect);
			Image component = _brushShapeMenuObject.GetComponent<Image>();
			((Graphic)component).color = TerminalDialogColor;
			((Graphic)component).raycastTarget = true;
			ApplyTerminalOutline(_brushShapeMenuObject, TerminalOutlineColor);
			BrushShape[] array = (BrushShape[])Enum.GetValues(typeof(BrushShape));
			for (int i = 0; i < array.Length; i++)
			{
				BrushShape shape = array[i];
				Button item = CreateAnchoredButton(_brushShapeMenuObject.transform, BrushShapeDisplayName(shape), new Rect(6f, 6f + (float)i * 28f, ((Rect)(ref rect)).width - 12f, 26f), delegate
				{
					SelectBrushShape(shape);
				});
				_brushShapeOptionButtons.Add(item);
			}
			_brushShapeMenuObject.SetActive(false);
		}

		private void BuildStickerShapeMenu(Transform parent, Rect rect)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			_stickerShapeOptionButtons.Clear();
			_stickerShapeMenuObject = CreateUiObject("StickerShapeDropdown", parent, typeof(RectTransform), typeof(Image));
			SetAnchoredRect(_stickerShapeMenuObject.GetComponent<RectTransform>(), rect);
			Image component = _stickerShapeMenuObject.GetComponent<Image>();
			((Graphic)component).color = TerminalDialogColor;
			((Graphic)component).raycastTarget = true;
			ApplyTerminalOutline(_stickerShapeMenuObject, TerminalOutlineColor);
			StickerShape[] array = (StickerShape[])Enum.GetValues(typeof(StickerShape));
			float num = 26f;
			float num2 = (((Rect)(ref rect)).width - 12f - 12f) / 3f;
			Rect rect2 = default(Rect);
			for (int i = 0; i < array.Length; i++)
			{
				StickerShape shape = array[i];
				int num3 = i % 3;
				int num4 = i / 3;
				((Rect)(ref rect2))..ctor(6f + (float)num3 * (num2 + 6f), 6f + (float)num4 * (num + 6f), num2, num);
				Button item = CreateAnchoredButton(_stickerShapeMenuObject.transform, StickerShapeShortName(shape), rect2, delegate
				{
					SelectStickerShape(shape);
				});
				_stickerShapeOptionButtons.Add(item);
			}
			_stickerShapeMenuObject.SetActive(false);
		}

		private static void ClearSelectedNormalButton()
		{
			EventSystem current = EventSystem.current;
			GameObject val = (((Object)(object)current != (Object)null) ? current.currentSelectedGameObject : null);
			if ((Object)(object)val != (Object)null && (Object)(object)val.GetComponent<InputField>() == (Object)null && (Object)(object)val.GetComponent<DrawableSliderControl>() == (Object)null && (Object)(object)val.GetComponent<DrawableColorPickerControl>() == (Object)null)
			{
				current.SetSelectedGameObject((GameObject)null);
			}
		}

		private bool CanHandlePlacementRotationShortcuts()
		{
			if (CanUsePlacementRotationShortcut() && !IsTypingInInputField())
			{
				return !IsVirtualPointerEditingUi();
			}
			return false;
		}

		private bool CanHandleUvPanelRotationShortcuts()
		{
			if (!IsTypingInInputField() && !IsVirtualPointerEditingUi() && (Object)(object)_previewViewportRect != (Object)null)
			{
				return (Object)(object)_previewImage != (Object)null;
			}
			return false;
		}

		private bool IsTypingInInputField()
		{
			if (IsInputFocused(_designNameInput) || IsInputFocused(_textStampInput) || IsInputFocused(_colorHexInput) || IsInputFocused(_designCodeInput) || IsInputFocused(_virtualPointerInput))
			{
				return true;
			}
			EventSystem val = EventSystem.current ?? _editorEventSystem;
			GameObject val2 = (((Object)(object)val != (Object)null) ? val.currentSelectedGameObject : null);
			if ((Object)(object)val2 == (Object)null)
			{
				return false;
			}
			if (!IsInputFocused(val2.GetComponent<InputField>()))
			{
				return IsInputFocused(val2.GetComponentInParent<InputField>());
			}
			return true;
		}

		private bool IsVirtualPointerEditingUi()
		{
			if (!_virtualPointerDown && !((Object)(object)_virtualPointerSlider != (Object)null))
			{
				return (Object)(object)_virtualPointerColorPicker != (Object)null;
			}
			return true;
		}

		private static bool IsInputFocused(InputField input)
		{
			if ((Object)(object)input != (Object)null)
			{
				return input.isFocused;
			}
			return false;
		}

		private static Sprite GetSliderHandleDotSprite()
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)SliderHandleDotSprite != (Object)null)
			{
				return SliderHandleDotSprite;
			}
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(11.5f, 11.5f);
			Color32[] array = (Color32[])(object)new Color32[576];
			for (int i = 0; i < 24; i++)
			{
				for (int j = 0; j < 24; j++)
				{
					float num = Vector2.Distance(new Vector2((float)j, (float)i), val);
					float num2 = Mathf.Clamp01((11f - num) / Mathf.Max(0.001f, 1.5f));
					array[i * 24 + j] = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, (byte)Mathf.RoundToInt(num2 * 255f));
				}
			}
			SliderHandleDotTexture = new Texture2D(24, 24, (TextureFormat)4, false)
			{
				name = "DrawableSuitsSliderHandleDot",
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1,
				hideFlags = (HideFlags)61
			};
			SliderHandleDotTexture.SetPixels32(array);
			SliderHandleDotTexture.Apply(false, false);
			SliderHandleDotSprite = Sprite.Create(SliderHandleDotTexture, new Rect(0f, 0f, 24f, 24f), new Vector2(0.5f, 0.5f), 24f);
			((Object)SliderHandleDotSprite).name = "DrawableSuitsSliderHandleDotSprite";
			return SliderHandleDotSprite;
		}

		private static DrawableSliderControl CreateAnchoredSlider(Transform parent, string name, float min, float max, float value, Rect rect, Action<float> onValueChanged)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUiObject(name + "Slider", parent, typeof(RectTransform), typeof(Image), typeof(DrawableSliderControl));
			SetAnchoredRect(val.GetComponent<RectTransform>(), rect);
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = new Color(1f, 1f, 1f, 0.001f);
			((Graphic)component).raycastTarget = true;
			GameObject obj = CreateUiObject("Track", val.transform, typeof(RectTransform), typeof(Image));
			RectTransform component2 = obj.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0f, 0.5f);
			component2.anchorMax = new Vector2(1f, 0.5f);
			component2.pivot = new Vector2(0.5f, 0.5f);
			component2.offsetMin = new Vector2(0f, -4f);
			component2.offsetMax = new Vector2(0f, 4f);
			Image component3 = obj.GetComponent<Image>();
			((Graphic)component3).color = TerminalSliderTrackColor;
			((Graphic)component3).raycastTarget = true;
			GameObject obj2 = CreateUiObject("Fill", val.transform, typeof(RectTransform), typeof(Image));
			RectTransform component4 = obj2.GetComponent<RectTransform>();
			component4.anchorMin = new Vector2(0f, 0.5f);
			component4.anchorMax = new Vector2(1f, 0.5f);
			component4.pivot = new Vector2(0f, 0.5f);
			component4.offsetMin = new Vector2(0f, -4f);
			component4.offsetMax = new Vector2(0f, 4f);
			Image component5 = obj2.GetComponent<Image>();
			((Graphic)component5).color = TerminalSliderFillColor;
			((Graphic)component5).raycastTarget = false;
			GameObject obj3 = CreateUiObject("Handle", val.transform, typeof(RectTransform), typeof(Image));
			RectTransform component6 = obj3.GetComponent<RectTransform>();
			component6.anchorMin = new Vector2(0f, 0.5f);
			component6.anchorMax = new Vector2(0f, 0.5f);
			component6.pivot = new Vector2(0.5f, 0.5f);
			component6.anchoredPosition = Vector2.zero;
			component6.sizeDelta = new Vector2(14f, 14f);
			Image component7 = obj3.GetComponent<Image>();
			component7.sprite = GetSliderHandleDotSprite();
			component7.type = (Type)0;
			component7.preserveAspect = true;
			((Graphic)component7).color = TerminalAccentHotColor;
			((Graphic)component7).raycastTarget = true;
			DrawableSliderControl component8 = val.GetComponent<DrawableSliderControl>();
			((Selectable)component8).targetGraphic = (Graphic)(object)component7;
			component8.Configure(component2, component4, component6, min, max, value, onValueChanged);
			object[] obj4 = new object[8] { name, rect, null, null, null, null, null, null };
			Rect rect2 = component2.rect;
			obj4[2] = ((Rect)(ref rect2)).size;
			rect2 = component4.rect;
			obj4[3] = ((Rect)(ref rect2)).size;
			rect2 = component6.rect;
			obj4[4] = ((Rect)(ref rect2)).size;
			obj4[5] = min;
			obj4[6] = max;
			obj4[7] = value;
			DrawableSuitsDiagnostics.Info(string.Format("DrawableSliderBuilt name={0}; root={1}; trackSize={2}; fillSize={3}; handleSize={4}; min={5}; max={6}; value={7}", obj4));
			return component8;
		}

		private static DrawableColorPickerControl CreateAnchoredColorPicker(Transform parent, Rect rect, Color initialColor, Action<Color> onColorChanged, out Image swatch, out InputField hexInput)
		{
			//IL_003f: 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_00be: 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_013d: 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_0182: 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_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUiObject("ColorPicker", parent, typeof(RectTransform), typeof(Image), typeof(DrawableColorPickerControl));
			SetAnchoredRect(val.GetComponent<RectTransform>(), rect);
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = new Color(1f, 1f, 1f, 0.001f);
			((Graphic)component).raycastTarget = true;
			GameObject obj = CreateUiObject("HueRing", val.transform, typeof(RectTransform), typeof(RawImage));
			RectTransform component2 = obj.GetComponent<RectTransform>();
			SetAnchoredRect(component2, new Rect(0f, 8f, 88f, 88f));
			RawImage component3 = obj.GetComponent<RawImage>();
			GameObject obj2 = CreateUiObject("SaturationValue", val.transform, typeof(RectTransform), typeof(RawImage));
			RectTransform component4 = obj2.GetComponent<RectTransform>();
			SetAnchoredRect(component4, new Rect(100f, 8f, 88f, 88f));
			RawImage component5 = obj2.GetComponent<RawImage>();
			RectTransform hueHandle = CreateColorPickerHandle((Transform)(object)component2, "HueHandle", new Vector2(16f, 16f));
			RectTransform svHandle = CreateColorPickerHandle((Transform)(object)component4, "SaturationValueHandle", new Vector2(14f, 14f));
			swatch = CreateAnchoredColorSwatch(val.transform, new Rect(204f, 8f, 54f, 48f));
			hexInput = CreateAnchoredInputField(val.transform, "ColorHexInput", ColorToHex(initialColor), new Rect(192f, 64f, 82f, 30f));
			hexInput.characterLimit = 7;
			hexInput.contentType = (ContentType)0;
			hexInput.textComponent.alignment = (TextAnchor)4;
			hexInput.textComponent.fontStyle = (FontStyle)1;
			DrawableColorPickerControl component6 = val.GetComponent<DrawableColorPickerControl>();
			((Selectable)component6).targetGraphic = (Graphic)(object)component;
			component6.Configure(component2, component4, hueHandle, svHandle, component3, component5, swatch, initialColor, onColorChanged);
			ColorBlock colors = ((Selectable)component6).colors;
			((ColorBlock)(ref colors)).normalColor = Color.white;
			((ColorBlock)(ref colors)).highlightedColor = Color.white;
			((ColorBlock)(ref colors)).pressedColor = Color.white;
			((ColorBlock)(ref colors)).selectedColor = Color.white;
			((Selectable)component6).colors = colors;
			DrawableSuitsDiagnostics.Info($"DrawableColorPickerBuilt root={rect}; hueRect={component2.rect}; svRect={component4.rect}; initialColor={initialColor}");
			return component6;
		}

		private static RectTransform CreateColorPickerHandle(Transform parent, string name, Vector2 size)
		{
			//IL_002a: 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_005f: 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_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_008c: 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_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_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: 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_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = CreateUiObject(name, parent, typeof(RectTransform)).GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.sizeDelta = size;
			CreateHandleLine(component, "Top", new Vector2(0f, size.y * 0.5f), new Vector2(size.x, 2f));
			CreateHandleLine(component, "Bottom", new Vector2(0f, (0f - size.y) * 0.5f), new Vector2(size.x, 2f));
			CreateHandleLine(component, "Left", new Vector2((0f - size.x) * 0.5f, 0f), new Vector2(2f, size.y));
			CreateHandleLine(component, "Right", new Vector2(size.x * 0.5f, 0f), new Vector2(2f, size.y));
			return component;
		}

		private static void CreateHandleLine(RectTransform parent, string name, Vector2 position, Vector2 size)
		{
			//IL_0038: 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_0062: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreateUiObject(name, (Transform)(object)parent, typeof(RectTransform), typeof(Image));
			RectTransform component = obj.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = position;
			component.sizeDelta = size;
			Image component2 = obj.GetComponent<Image>();
			((Graphic)component2).color = Color.white;
			((Graphic)component2).raycastTarget = false;
		}

		private static Image CreateAnchoredColorSwatch(Transform parent, Rect rect)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreateUiObject("ColorSwatch", parent, typeof(RectTransform), typeof(Image));
			SetAnchoredRect(obj.GetComponent<RectTransform>(), rect);
			return obj.GetComponent<Image>();
		}

		private static InputField CreateAnchoredInputField(Transform parent, string value, Rect rect)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return CreateAnchoredInputField(parent, "DesignNameInput", value, rect);
		}

		private static InputField CreateAnchoredInputField(Transform parent, string name, string value, Rect rect)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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_009e: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: 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)
			GameObject val = CreateUiObject(name, parent, typeof(RectTransform), typeof(Image), typeof(InputField));
			SetAnchoredRect(val.GetComponent<RectTransform>(), rect);
			((Graphic)val.GetComponent<Image>()).color = TerminalInputColor;
			ApplyTerminalOutline(val, TerminalOutlineColor);
			GameObject obj = CreateUiObject("Text", val.transform, typeof(RectTransform), typeof(Text));
			RectTransform component = obj.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = new Vector2(8f, 2f);
			component.offsetMax = new Vector2(-8f, -2f);
			Text component2 = obj.GetComponent<Text>();
			component2.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			component2.fontSize = 16;
			((Graphic)component2).color = TerminalTextColor;
			component2.alignment = (TextAnchor)3;
			component2.horizontalOverflow = (HorizontalWrapMode)1;
			component2.verticalOverflow = (VerticalWrapMode)0;
			((Graphic)component2).raycastTarget = false;
			InputField component3 = val.GetComponent<InputField>();
			component3.textComponent = component2;
			component3.text = value;
			component3.lineType = (LineType)0;
			component3.caretColor = TerminalTextColor;
			component3.selectionColor = new Color(TerminalAccentHotColor.r, TerminalAccentHotColor.g, TerminalAccentHotColor.b, 0.45f);
			return component3;
		}

		private static RectTransform CreateAnchoredScrollList(Transform parent, string name, Rect rect)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreateUiObject(name, parent, typeof(RectTransform), typeof(Image));
			RectTransform component = obj.GetComponent<RectTransform>();
			SetAnchoredRect(component, rect);
			Image component2 = obj.GetComponent<Image>();
			((Graphic)component2).color = TerminalCardColor;
			((Graphic)component2).raycastTarget = true;
			ApplyTerminalOutline(obj, TerminalOutlineColor);
			return component;
		}

		private void BeginEditorUiInput()
		{
			if (_editorUiInputActive)
			{
				return;
			}
			EnsureOwnedEventSystem();
			_eventSystemRestoreStates.Clear();
			EventSystem[] array = Object.FindObjectsOfType<EventSystem>(true);
			foreach (EventSystem val in array)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)val == (Object)(object)_editorEventSystem)
				{
					continue;
				}
				BaseInputModule[] components = ((Component)val).GetComponents<BaseInputModule>();
				EventSystemRestoreState eventSystemRestoreState = new EventSystemRestoreState
				{
					EventSystem = val,
					GameObjectActive = ((Component)val).gameObject.activeSelf,
					EventSystemEnabled = ((Behaviour)val).enabled,
					Modules = components,
					ModuleEnabled = new bool[components.Length]
				};
				for (int j = 0; j < components.Length; j++)
				{
					eventSystemRestoreState.ModuleEnabled[j] = (Object)(object)components[j] != (Object)null && ((Behaviour)components[j]).enabled;
					if ((Object)(object)components[j] != (Object)null)
					{
						((Behaviour)components[j]).enabled = false;
					}
				}
				((Behaviour)val).enabled = false;
				_eventSystemRestoreStates.Add(eventSystemRestoreState);
			}
			_editorEventSystemObject.SetActive(true);
			((Behaviour)_editorEventSystem).enabled = true;
			((Behaviour)_editorInputModule).enabled = true;
			InputActionAsset editorUiActions = _editorUiActions;
			if (editorUiActions != null)
			{
				editorUiActions.Enable();
			}
			EventSystem.current = _editorEventSystem;
			_editorUiInputActive = true;
			object[] obj = new object[4]
			{
				DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_editorEventSystem),
				_eventSystemRestoreStates.Count,
				null,
				null
			};
			EventSystem current = EventSystem.current;
			obj[2] = ((current != null) ? ((Object)current).name : null) ?? "null";
			obj[3] = ((object)_editorInputModule).GetType().Name;
			DrawableSuitsDiagnostics.Info(string.Format("DrawableSuits editor UI input enabled. ownedEventSystem={0}; disabledEventSystems={1}; current={2}; module={3}", obj));
		}

		private void EndEditorUiInput()
		{
			if (!_editorUiInputActive)
			{
				InputActionAsset editorUiActions = _editorUiActions;
				if (editorUiActions != null)
				{
					editorUiActions.Disable();
				}
				if ((Object)(object)_editorInputModule != (Object)null)
				{
					((Behaviour)_editorInputModule).enabled = false;
				}
				if ((Object)(object)_editorEventSystem != (Object)null)
				{
					((Behaviour)_editorEventSystem).enabled = false;
				}
				if ((Object)(object)_editorEventSystemObject != (Object)null)
				{
					_editorEventSystemObject.SetActive(false);
				}
				return;
			}
			InputActionAsset editorUiActions2 = _editorUiActions;
			if (editorUiActions2 != null)
			{
				editorUiActions2.Disable();
			}
			if ((Object)(object)_editorInputModule != (Object)null)
			{
				((Behaviour)_editorInputModule).enabled = false;
			}
			if ((Object)(object)_editorEventSystem != (Object)null)
			{
				((Behaviour)_editorEventSystem).enabled = false;
			}
			if ((Object)(object)_editorEventSystemObject != (Object)null)
			{
				_editorEventSystemObject.SetActive(false);
			}
			EventSystem val = null;
			foreach (EventSystemRestoreState eventSystemRestoreState in _eventSystemRestoreStates)
			{
				if ((Object)(object)eventSystemRestoreState?.EventSystem == (Object)null)
				{
					continue;
				}
				((Component)eventSystemRestoreState.EventSystem).gameObject.SetActive(eventSystemRestoreState.GameObjectActive);
				((Behaviour)eventSystemRestoreState.EventSystem).enabled = eventSystemRestoreState.EventSystemEnabled;
				if (eventSystemRestoreState.Modules != null && eventSystemRestoreState.ModuleEnabled != null)
				{
					for (int i = 0; i < eventSystemRestoreState.Modules.Length && i < eventSystemRestoreState.ModuleEnabled.Length; i++)
					{
						if ((Object)(object)eventSystemRestoreState.Modules[i] != (Object)null)
						{
							((Behaviour)eventSystemRestoreState.Modules[i]).enabled = eventSystemRestoreState.ModuleEnabled[i];
						}
					}
				}
				if ((Object)(object)val == (Object)null && eventSystemRestoreState.GameObjectActive && eventSystemRestoreState.EventSystemEnabled)
				{
					val = eventSystemRestoreState.EventSystem;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				EventSystem[] array = Object.FindObjectsOfType<EventSystem>(true);
				foreach (EventSystem val2 in array)
				{
					if ((Object)(object)val2 != (Object)null && (Object)(object)val2 != (Object)(object)_editorEventSystem && ((Component)val2).gameObject.activeInHierarchy && ((Behaviour)val2).enabled)
					{
						val = val2;
						break;
					}
				}
			}
			EventSystem.current = val;
			object arg = _eventSystemRestoreStates.Count;
			EventSystem current2 = EventSystem.current;
			DrawableSuitsDiagnostics.Info(string.Format("DrawableSuits editor UI input disabled. restoredEventSystems={0}; current={1}", arg, ((current2 != null) ? ((Object)current2).name : null) ?? "null"));
			_eventSystemRestoreStates.Clear();
			_editorUiInputActive = false;
		}

		private void EnsureOwnedEventSystem()
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			if (!((Object)(object)_editorEventSystemObject != (Object)null) || !((Object)(object)_editorEventSystem != (Object)null) || !((Object)(object)_editorInputModule != (Object)null))
			{
				_editorEventSystemObject = new GameObject("DrawableSuitsEditorEventSystem", new Type[2]
				{
					typeof(EventSystem),
					typeof(InputSystemUIInputModule)
				});
				Object.DontDestroyOnLoad((Object)(object)_editorEventSystemObject);
				_editorEventSystem = _editorEventSystemObject.GetComponent<EventSystem>();
				_editorInputModule = _editorEventSystemObject.GetComponent<InputSystemUIInputModule>();
				ConfigureInputSystemUiModule(_editorInputModule);
				_editorEventSystemObject.SetActive(false);
				DrawableSuitsDiagnostics.Info("Created DrawableSuits-owned EventSystem with InputSystemUIInputModule.");
			}
		}

		private void ConfigureInputSystemUiModule(InputSystemUIInputModule module)
		{
			//IL_0075: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)module == (Object)null))
			{
				_editorUiActions = ScriptableObject.CreateInstance<InputActionAsset>();
				((Object)_editorUiActions).name = "DrawableSuitsUIActions";
				Object.DontDestroyOnLoad((Object)(object)_editorUiActions);
				InputActionMap obj = InputActionSetupExtensions.AddActionMap(_editorUiActions, "UI");
				InputAction val = InputActionSetupExtensions.AddAction(obj, "Point", (InputActionType)2, "<Pointer>/position", (string)null, (string)null, (string)null, (string)null);
				InputAction val2 = InputActionSetupExtensions.AddAction(obj, "LeftClick", (InputActionType)1, "<Mouse>/leftButton", (string)null, (string)null, (string)null, (string)null);
				InputActionSetupExtensions.AddBinding(val2, "<Pointer>/press", (string)null, (string)null, (string)null);
				InputAction val3 = InputActionSetupExtensions.AddAction(obj, "ScrollWheel", (InputActionType)2, "<Pointer>/scroll", (string)null, (string)null, (string)null, (string)null);
				InputAction val4 = InputActionSetupExtensions.AddAction(obj, "Move", (InputActionType)2, (string)null, (string)null, (string)null, (string)null, (string)null);
				CompositeSyntax val5 = InputActionSetupExtensions.AddCompositeBinding(val4, "2DVector", (string)null, (string)null);
				val5 = ((CompositeSyntax)(ref val5)).With("Up", "<Keyboard>/upArrow", (string)null, (string)null);
				val5 = ((CompositeSyntax)(ref val5)).With("Down", "<Keyboard>/downArrow", (string)null, (string)null);
				val5 = ((CompositeSyntax)(ref val5)).With("Left", "<Keyboard>/leftArrow", (string)null, (string)null);
				((CompositeSyntax)(ref val5)).With("Right", "<Keyboard>/rightArrow", (string)null, (string)null);
				InputActionSetupExtensions.AddBinding(val4, "<Gamepad>/dpad", (string)null, (string)null, (string)null);
				InputAction val6 = InputActionSetupExtensions.AddAction(obj, "Submit", (InputActionType)1, (string)null, (string)null, (string)null, (string)null, (string)null);
				InputActionSetupExtensions.AddBinding(val6, "<Keyboard>/enter", (string)null, (string)null, (string)null);
				InputAction val7 = InputActionSetupExtensions.AddAction(obj, "Cancel", (InputActionType)1, (string)null, (string)null, (string)null, (string)null, (string)null);
				InputActionSetupExtensions.AddBinding(val7, "<Keyboard>/escape", (string)null, (string)null, (string)null);
				InputActionSetupExtensions.AddBinding(val7, "<Gamepad>/buttonEast", (string)null, (string)null, (string)null);
				module.actionsAsset = _editorUiActions;
				module.point = InputActionReference.Create(val);
				module.leftClick = InputActionReference.Create(val2);
				module.scrollWheel = InputActionReference.Create(val3);
				module.move = InputActionReference.Create(val4);
				module.submit = InputActionReference.Create(val6);
				module.cancel = InputActionReference.Create(val7);
			}
		}

		private void InitializePointerForOpen(string source)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			_mousePositionAvailable = DrawableSuitsInput.TryGetMousePosition(out _lastMousePosition);
			_lastGamepadStick = ((Gamepad.current != null) ? ((InputControl<Vector2>)(object)Gamepad.current.leftStick).ReadValue() : Vector2.zero);
			_usingGamepadPointer = false;
			_gamepadClickArmed = false;
			_virtualPointerDown = false;
			_virtualPointerPressTarget = null;
			_virtualPointerSlider = null;
			_virtualPointerColorPicker = null;
			_virtualPointerButton = null;
			_virtualPointerInput = null;
			_pointerSource = "Mouse";
			_cursor = (Vector2)(_mousePositionAvailable ? _lastMousePosition : new Vector2((float)Screen.width * 0.5f, (float)Screen.height * 0.5f));
			DrawableSuitsDiagnostics.Info($"Pointer initialized for editor open. source={source}; pointerSource={_pointerSource}; gamepadClickArmed={_gamepadClickArmed}; mouseAvailable={_mousePositionAvailable}; mouse={_lastMousePosition}; gamepadStick={_lastGamepadStick}; cursor={_cursor}; cursorVisible={Cursor.visible}; cursorLock={Cursor.lockState}");
		}

		private void EnsureCursorUnlockedWhileOpen()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (_isOpen && (Cursor.visible || (int)Cursor.lockState != 0))
			{
				DrawableSuitsDiagnostics.Warn($"Editor native cursor state changed while open; restoring hidden canvas-cursor mode. visibleBefore={Cursor.visible}; lockBefore={Cursor.lockState}; pointerSource={_pointerSource}");
				Cursor.visible = false;
				Cursor.lockState = (CursorLockMode)0;
			}
		}

		private void CaptureAndUnlockCursor()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (!_cursorStateCaptured)
			{
				_previousCursorVisible = Cursor.visible;
				_previousCursorLockState = Cursor.lockState;
				_cursorStateCaptured = true;
			}
			Cursor.visible = false;
			Cursor.lockState = (CursorLockMode)0;
			DrawableSuitsDiagnostics.Info($"Cursor captured for editor canvas cursor. previousVisible={_previousCursorVisible}; previousLock={_previousCursorLockState}; currentVisible={Cursor.visible}; currentLock={Cursor.lockState}");
		}

		private void SetStatus(string message, bool warn)
		{
			_statusMessage = message ?? string.Empty;
			if ((Object)(object)_statusLabel != (Object)null)
			{
				_statusLabel.text = _statusMessage;
				((Component)_statusLabel).gameObject.SetActive(!string.IsNullOrWhiteSpace(_statusMessage));
			}
			if (warn && !string.IsNullOrWhiteSpace(_statusMessage))
			{
				DrawableSuitsDiagnostics.Warn(_statusMessage);
			}
		}

		internal void ShowExternalStatus(string message, bool warn)
		{
			if (_isOpen)
			{
				SetStatus(message, warn);
			}
		}

		private void RestoreCursorState(bool leaveUnlockedForSceneChange)
		{
			//IL_0035: 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)
			if (!_cursorStateCaptured)
			{
				if (leaveUnlockedForSceneChange)
				{
					Cursor.visible = true;
					Cursor.lockState = (CursorLockMode)0;
				}
				return;
			}
			if (leaveUnlockedForSceneChange)
			{
				Cursor.visible = true;
				Cursor.lockState = (CursorLockMode)0;
			}
			else
			{
				Cursor.visible = _previousCursorVisible;
				Cursor.lockState = _previousCursorLockState;
			}
			_cursorStateCaptured = false;
			DrawableSuitsDiagnostics.Info($"Cursor restored after editor close. leaveUnlocked={leaveUnlockedForSceneChange}; visible={Cursor.visible}; lock={Cursor.lockState}");
		}

		private void CaptureAndLockGameplayActions()
		{
			_disabledGameplayActions.Clear();
			InputActionAsset actions = InputSystem.actions;
			if ((Object)(object)actions == (Object)null)
			{
				DrawableSuitsDiagnostics.Info("Global gameplay action lock skipped: InputSystem.actions is null.");
				return;
			}
			int num = 0;
			int num2 = 0;
			List<string> list = new List<string>();
			for (int i = 0; i < GameplayInputActionNames.Length; i++)
			{
				string text = GameplayInputActionNames[i];
				InputAction val = null;
				try
				{
					val = actions.FindAction(text, false);
				}
				catch (Exception exception)
				{
					DrawableSuitsDiagnostics.Exception("Global gameplay action lookup failed for '" + text + "'", exception);
				}
				if (val == null)
				{
					list.Add(text);
					continue;
				}
				num++;
				bool enabled = val.enabled;
				_disabledGameplayActions.Add(new DisabledGameplayActionState
				{
					Action = val,
					WasEnabled = enabled,
					Name = text
				});
				if (enabled)
				{
					try
					{
						val.Disable();
						num2++;
					}
					catch (Exception exception2)
					{
						DrawableSuitsDiagnostics.Exception("Failed to disable global gameplay action '" + text + "'", exception2);
					}
				}
			}
			DrawableSuitsDiagnostics.Info(string.Format("Global gameplay actions locked for editor. found={0}; disabled={1}; missing=[{2}]", num, num2, string.Join(", ", list)));
		}

		private void ReapplyGameplayActionLock()
		{
			if (_disabledGameplayActions.Count == 0)
			{
				return;
			}
			int num = 0;
			for (int i = 0; i < _disabledGameplayActions.Count; i++)
			{
				DisabledGameplayActionState disabledGameplayActionState = _disabledGameplayActions[i];
				if (disabledGameplayActionState?.Action != null && disabledGameplayActionState.Action.enabled)
				{
					try
					{
						disabledGameplayActionState.Action.Disable();
						num++;
					}
					catch (Exception exception)
					{
						DrawableSuitsDiagnostics.Exception("Failed to re-disable global gameplay action '" + disabledGameplayActionState.Name + "'", exception);
					}
				}
			}
			if (num > 0 && Time.unscaledTime - _lastGameplayActionRelockLogTime > 0.75f)
			{
				_lastGameplayActionRelockLogTime = Time.unscaledTime;
				DrawableSuitsDiagnostics.Warn($"Re-disabled {num} global gameplay actions while DrawableSuits editor is open.");
			}
		}

		private void RestoreGameplayActions()
		{
			if (_disabledGameplayActions.Count == 0)
			{
				return;
			}
			int num = 0;
			int num2 = 0;
			for (int i = 0; i < _disabledGameplayActions.Count; i++)
			{
				DisabledGameplayActionState disabledGameplayActionState = _disabledGameplayActions[i];
				if (disabledGameplayActionState?.Action == null)
				{
					continue;
				}
				try
				{
					if (disabledGameplayActionState.WasEnabled && !disabledGameplayActionState.Action.enabled)
					{
						disabledGameplayActionState.Action.Enable();
						num++;
					}
					else if (!disabledGameplayActionState.WasEnabled && disabledGameplayActionState.Action.enabled)
					{
						disabledGameplayActionState.Action.Disable();
						num2++;
					}
				}
				catch (Exception exception)
				{
					DrawableSuitsDiagnostics.Exception("Failed to restore global gameplay action '" + disabledGameplayActionState.Name + "'", exception);
				}
			}
			DrawableSuitsDiagnostics.Info($"Global gameplay actions restored after editor close. tracked={_disabledGameplayActions.Count}; reEnabled={num}; reDisabled={num2}");
			_disabledGameplayActions.Clear();
		}

		private void CaptureAndLockPlayerInput()
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB val = StartOfRound.Instance?.localPlayerController;
			if ((Object)(object)val == (Object)null)
			{
				DrawableSuitsDiagnostics.Info("Player input lock skipped: local player is null.");
				_playerInputStateCaptured = false;
				_inputLockedPlayer = null;
				return;
			}
			_inputLockedPlayer = val;
			_previousDisableMoveInput = val.disableMoveInput;
			_previousDisableLookInput = val.disableLookInput;
			_previousDisableInteract = val.disableInteract;
			_previousInSpecialMenu = val.inSpecialMenu;
			MovementActions movement = val.playerActions.Movement;
			_previousMovementActionsEnabled = ((MovementActions)(ref movement)).enabled;
			_playerInputStateCaptured = true;
			CaptureAndLockGameplayActions();
			ApplyPlayerInputLock(val, logActionMap: true);
			DrawableSuitsDiagnostics.Info($"Player input locked for editor. player={DrawableSuitsPlugin.DescribeUnityObject((Object)(object)val)}; previousMove={_previousDisableMoveInput}; previousLook={_previousDisableLookInput}; previousInteract={_previousDisableInteract}; previousSpecialMenu={_previousInSpecialMenu}; movementActionsWereEnabled={_previousMovementActionsEnabled}");
		}

		private void ReapplyPlayerInputLock()
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			ReapplyGameplayActionLock();
			if (!_playerInputStateCaptured)
			{
				return;
			}
			PlayerControllerB val = StartOfRound.Instance?.localPlayerController;
			if (!((Object)(object)val == (Object)null))
			{
				if ((Object)(object)_inputLockedPlayer != (Object)(object)val)
				{
					DrawableSuitsDiagnostics.Warn("Player input lock target changed while editor was open. old=" + DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_inputLockedPlayer) + "; new=" + DrawableSuitsPlugin.DescribeUnityObject((Object)(object)val));
					_inputLockedPlayer = val;
					_previousDisableMoveInput = val.disableMoveInput;
					_previousDisableLookInput = val.disableLookInput;
					_previousDisableInteract = val.disableInteract;
					_previousInSpecialMenu = val.inSpecialMenu;
					MovementActions movement = val.playerActions.Movement;
					_previousMovementActionsEnabled = ((MovementActions)(ref movement)).enabled;
				}
				ApplyPlayerInputLock(val, logActionMap: false);
			}
		}

		private void RestorePlayerInputState()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: 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)
			if (!_playerInputStateCaptured)
			{
				RestoreGameplayActions();
				return;
			}
			MovementActions movement;
			if ((Object)(object)_inputLockedPlayer != (Object)null)
			{
				_inputLockedPlayer.disableMoveInput = _previousDisableMoveInput;
				_inputLockedPlayer.disableLookInput = _previousDisableLookInput;
				_inputLockedPlayer.disableInteract = _previousDisableInteract;
				_inputLockedPlayer.inSpecialMenu = _previousInSpecialMenu;
				if (_previousMovementActionsEnabled)
				{
					movement = _inputLockedPlayer.playerActions.Movement;
					if (!((MovementActions)(ref movement)).enabled)
					{
						movement = _inputLockedPlayer.playerActions.Movement;
						((MovementActions)(ref movement)).Enable();
						goto IL_00da;
					}
				}
				if (!_previousMovementActionsEnabled)
				{
					movement = _inputLockedPlayer.playerActions.Movement;
					if (((MovementActions)(ref movement)).enabled)
					{
						movement = _inputLockedPlayer.playerActions.Movement;
						((MovementActions)(ref movement)).Disable();
					}
				}
				goto IL_00da;
			}
			DrawableSuitsDiagnostics.Info("Player input restore skipped because locked player was destroyed or unavailable.");
			goto IL_0175;
			IL_00da:
			object[] obj = new object[6]
			{
				DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_inputLockedPlayer),
				_inputLockedPlayer.disableMoveInput,
				_inputLockedPlayer.disableLookInput,
				_inputLockedPlayer.disableInteract,
				_inputLockedPlayer.inSpecialMenu,
				null
			};
			movement = _inputLockedPlayer.playerActions.Movement;
			obj[5] = ((MovementActions)(ref movement)).enabled;
			DrawableSuitsDiagnostics.Info(string.Format("Player input restored after editor close. player={0}; move={1}; look={2}; interact={3}; specialMenu={4}; movementActionsEnabled={5}", obj));
			goto IL_0175;
			IL_0175:
			RestoreGameplayActions();
			_inputLockedPlayer = null;
			_playerInputStateCaptured = false;
		}

		private static void ApplyPlayerInputLock(PlayerControllerB player, bool logActionMap)
		{
			//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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			player.disableMoveInput = true;
			player.disableLookInput = true;
			player.disableInteract = true;
			player.inSpecialMenu = true;
			player.moveInputVector = Vector2.zero;
			player.isHoldingInteract = false;
			MovementActions movement = player.playerActions.Movement;
			if (((MovementActions)(ref movement)).enabled)
			{
				movement = player.playerActions.Movement;
				((MovementActions)(ref movement)).Disable();
				if (logActionMap)
				{
					DrawableSuitsDiagnostics.Info("Disabled PlayerActions.Movement while DrawableSuits editor is open.");
				}
			}
		}

		private void UpdateUiState()
		{
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_suitLabel != (Object)null)
			{
				_suitLabel.text = ((_selectedSuitId >= 0) ? $"Suit: {DrawableSuitsPlugin.Registry.GetSuitName(_selectedSuitId)} ({_selectedSuitId})" : "Suit: current suit unavailable");
			}
			if ((Object)(object)_statusLabel != (Object)null)
			{
				_statusLabel.text = _statusMessage;
				((Component)_statusLabel).gameObject.SetActive(!string.IsNullOrWhiteSpace(_statusMessage));
			}
			if ((Object)(object)_designNameInput != (Object)null && _designNameInput.text != _designName)
			{
				_designNameInput.text = _designName;
			}
			if ((Object)(object)_textStampInput != (Object)null && _textStampInput.text != _textStampValue)
			{
				_textStampInput.SetTextWithoutNotify(_textStampValue);
			}
			if ((Object)(object)_brushSizeSlider != (Object)null)
			{
				_brushSizeSlider.SetValue(_brushSize, notify: false);
			}
			if ((Object)(object)_brushOpacitySlider != (Object)null)
			{
				_brushOpacitySlider.SetValue(_brushOpacity, notify: false);
			}
			if ((Object)(object)_fillToleranceSlider != (Object)null)
			{
				_fillToleranceSlider.SetValue(_fillTolerance, notify: false);
			}
			if ((Object)(object)_colorPicker != (Object)null)
			{
				_colorPicker.SetColor(_brushColor, notify: false);
			}
			if ((Object)(object)_decalSizeSlider != (Object)null)
			{
				_decalSizeSlider.SetValue(CurrentPlacementSize(), notify: false);
			}
			if ((Object)(object)_decalRotationSlider != (Object)null)
			{
				_decalRotationSlider.SetValue(CurrentPlacementRotation(), notify: false);
			}
			if (_usingTexturePreview)
			{
				UseTexturePreview("UpdateUiState", forceLog: false);
			}
			else
			{
				RefreshTexturePanelPreview("UpdateUiState", forceLog: false);
			}
			bool flag = _selectedSuitId >= 0 && (Object)(object)DrawableSuitsPlugin.Registry.GetEditableTexture(_selectedSuitId) != (Object)null;
			SetInteractable((Selectable)(object)_paintButton, _canPaint);
			SetInteractable((Selectable)(object)_eraseButton, _canPaint);
			SetInteractable((Selectable)(object)_fillButton, _canPaint && flag);
			SetInteractable((Selectable)(object)_decalButton, _canPaint);
			SetInteractable((Selectable)(object)_eyedropperButton, _canPaint && flag);
			SetInteractable((Selectable)(object)_textButton, _canPaint && flag);
			SetInteractable((Selectable)(object)_stickerButton, _canPaint && flag);
			SetInteractable((Selectable)(object)_mirrorButton, _canPaint && flag);
			SetInteractable((Selectable)(object)_brushShapeButton, _canPaint && flag);
			SetInteractable((Selectable)(object)_stickerShapeButton, _canPaint && flag);
			SetInteractable((Selectable)(object)_decalsMenuButton, _canPaint && flag);
			SetInteractable((Selectable)(object)_stickersMenuButton, _canPaint && flag);
			SetInteractable((Selectable)(object)_editDecalButton, _canPaint && flag && (Object)(object)_loadedDecal != (Object)null);
			SetInteractable((Selectable)(object)_editStickerButton, _canPaint && flag);
			SetInteractable((Selectable)(object)_applyButton, _canPaint && flag);
			SetInteractable((Selectable)(object)_saveButton, flag);
			SetInteractable((Selectable)(object)_exportCodeButton, flag);
			SetInteractable((Selectable)(object)_importCodeButton, flag);
			SetInteractable((Selectable)(object)_resetButton, flag);
			SetInteractable((Selectable)(object)_savedDesignsButton, flag);
			SetInteractable((Selectable)(object)_loadSelectedDesignButton, flag && _selectedDesignIndex >= 0);
			UpdateSavedDesignDeleteButton();
			UpdateDecalDeleteButton();
			UpdateAddDecalButton();
			if ((Object)(object)_uvFallbackButton != (Object)null)
			{
				bool active = _uvFallbackMode || !IsWorldThirdPersonMode;
				((Component)_uvFallbackButton).gameObject.SetActive(active);
				SetButtonLabel(_uvFallbackButton, _uvFallbackMode ? "Use Third Person" : "UV Panel Active");
			}
			if ((!_canPaint || !flag) && (Object)(object)_brushShapeMenuObject != (Object)null && _brushShapeMenuObject.activeSelf)
			{
				_brushShapeMenuObject.SetActive(false);
			}
			if ((!_canPaint || !flag) && (Object)(object)_stickerShapeMenuObject != (Object)null && _stickerShapeMenuObject.activeSelf)
			{
				_stickerShapeMenuObject.SetActive(false);
			}
			UpdateToolButtons();
			UpdateLabels();
			UpdateColorUi();
			UpdateRecentColorSwatches();
			UpdateUndoHistoryUi();
			RefreshPlacementEditPanelUi();
		}

		private static void SetInteractable(Selectable selectable, bool interactable)
		{
			if ((Object)(object)selectable != (Object)null)
			{
				selectable.interactable = interactable;
			}
		}

		private static void SetButtonLabel(Button button, string label)
		{
			if (!((Object)(object)button == (Object)null))
			{
				Text componentInChildren = ((Component)button).GetComponentInChildren<Text>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.text = label;
				}
			}
		}

		private void UpdateLabels()
		{
			bool flag = _tool == EditorTool.FillBucket;
			bool flag2 = _tool == EditorTool.Sticker;
			bool flag3 = _tool == EditorTool.Text;
			bool active = !flag3 && !flag2;
			bool flag4 = _brushShape == BrushShape.Pixel;
			if (flag)
			{
				HideBrushShapeMenu();
			}
			if (!flag2)
			{
				HideStickerShapeMenu();
			}
			if ((Object)(object)_brushShapeLabel != (Object)null)
			{
				((Component)_brushShapeLabel).gameObject.SetActive(!flag);
			}
			if ((Object)(object)_brushShapeButton != (Object)null)
			{
				((Component)_brushShapeButton).gameObject.SetActive(!flag);
			}
			if ((Object)(object)_brushSizeLabel != (Object)null)
			{
				_brushSizeLabel.text = (flag4 ? "Size: 1 px" : $"Size: {Mathf.RoundToInt(_brushSize)} px");
				((Component)_brushSizeLabel).gameObject.SetActive(!flag);
			}
			if ((Object)(object)_brushSizeSlider != (Object)null)
			{
				((Component)_brushSizeSlider).gameObject.SetActive(!flag && !flag4);
			}
			if ((Object)(object)_brushOpacityLabel != (Object)null)
			{
				_brushOpacityLabel.text = $"Opacity: {Mathf.RoundToInt(_brushOpacity * 100f)}%";
			}
			if ((Object)(object)_fillToleranceLabel != (Object)null)
			{
				_fillToleranceLabel.text = $"Tolerance: {Mathf.RoundToInt(_fillTolerance * 100f)}%";
				((Component)_fillToleranceLabel).gameObject.SetActive(flag);
			}
			if ((Object)(object)_fillToleranceSlider != (Object)null)
			{
				((Component)_fillToleranceSlider).gameObject.SetActive(flag);
			}
			if ((Object)(object)_placementHeaderLabel != (Object)null)
			{
				_placementHeaderLabel.text = (flag3 ? "Text" : (flag2 ? "Sticker" : "Decal"));
			}
			if ((Object)(object)_decalSizeLabel != (Object)null)
			{
				_decalSizeLabel.text = (flag3 ? $"Height: {Mathf.RoundToInt(_textSize)} px" : (flag2 ? $"Size: {Mathf.RoundToInt(_stickerSize)} px" : $"Size: {Mathf.RoundToInt(_decalSize)} px"));
			}
			if ((Object)(object)_decalRotationLabel != (Object)null)
			{
				_decalRotationLabel.text = $"Rotation: {Mathf.RoundToInt(CurrentPlacementRotation())} deg";
			}
			if ((Object)(object)_textStampInput != (Object)null)
			{
				((Component)_textStampInput).gameObject.SetActive(flag3);
			}
			if ((Object)(object)_stickerShapeButton != (Object)null)
			{
				((Component)_stickerShapeButton).gameObject.SetActive(flag2);
			}
			if ((Object)(object)_stickersMenuButton != (Object)null)
			{
				((Component)_stickersMenuButton).gameObject.SetActive(flag2);
			}
			if ((Object)(object)_editStickerButton != (Object)null)
			{
				((Component)_editStickerButton).gameObject.SetActive(flag2);
			}
			if ((Object)(object)_selectedStickerShapeLabel != (Object)null)
			{
				((Component)((Component)_selectedStickerShapeLabel).gameObject.transform.parent).gameObject.SetActive(flag2);
				_selectedStickerShapeLabel.text = StickerShapeDisplayName(_stickerShape);
			}
			if ((Object)(object)_decalsMenuButton != (Object)null)
			{
				((Component)_decalsMenuButton).gameObject.SetActive(active);
			}
			if ((Object)(object)_editDecalButton != (Object)null)
			{
				((Component)_editDecalButton).gameObject.SetActive(active);
			}
			if ((Object)(object)_selectedDecalLabel != (Object)null)
			{
				((Component)((Component)_selectedDecalLabel).gameObject.transform.parent).gameObject.SetActive(active);
				_selectedDecalLabel.text = ((_selectedDecalIndex >= 0 && _selectedDecalIndex < _decalFiles.Count) ? MiddleEllipsize(Path.GetFileName(_decalFiles[_selectedDecalIndex]), 24) : "No decal selected");
			}
		}

		private float CurrentPlacementSize()
		{
			if (_tool != EditorTool.Text)
			{
				if (_tool != EditorTool.Sticker)
				{
					return _decalSize;
				}
				return _stickerSize;
			}
			return _textSize;
		}

		private float CurrentPlacementRotation()
		{
			if (_tool != EditorTool.Text)
			{
				if (_tool != EditorTool.Sticker)
				{
					return _decalRotation;
				}
				return _stickerRotation;
			}
			return _textRotation;
		}

		private bool CanUsePlacementRotationShortcut()
		{
			if (_tool != EditorTool.Decal || !((Object)(object)_loadedDecal != (Object)null))
			{
				return _tool == EditorTool.Sticker;
			}
			return true;
		}

		private void ApplyPlacementRotationShortcut(float deltaDegrees, string source)
		{
			if (CanUsePlacementRotationShortcut())
			{
				float num = CurrentPlacementRotation();
				float num2 = NormalizePlacementRotation(num + deltaDegrees);
				if (_tool == EditorTool.Sticker)
				{
					_stickerRotation = num2;
				}
				else
				{
					_decalRotation = num2;
				}
				if ((Object)(object)_decalRotationSlider != (Object)null)
				{
					_decalRotationSlider.SetValue(num2, notify: false);
				}
				UpdateLabels();
				InvalidateDecalPreview("placement rotation shortcut " + source);
				string arg = ToolDisplayName(_tool);
				SetStatus($"{arg} rotation: {Mathf.RoundToInt(num2)} deg.", warn: false);
				DrawableSuitsDiagnostics.Info($"PlacementRotationShortcutApplied: tool={_tool}; source={source}; previous={num:0.##}; new={num2:0.##}; delta={deltaDegrees:0.##}; selected={CurrentPlacementName()}; mirror={_mirrorEnabled}; suit={_selectedSuitId}");
			}
		}

		private static float NormalizePlacementRotation(float value)
		{
			while (value > 180f)
			{
				value -= 360f;
			}
			while (value < -180f)
			{
				value += 360f;
			}
			return Mathf.Clamp(value, -180f, 180f);
		}

		private void UpdateColorUi()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_colorSwatch != (Object)null)
			{
				((Graphic)_colorSwatch).color = _brushColor;
			}
			if ((Object)(object)_colorHexInput != (Object)null && !_colorHexInput.isFocused)
			{
				_colorHexInput.SetTextWithoutNotify(ColorToHex(_brushColor));
			}
			UpdateBrushIndicator();
		}

		private void PreviewHexInput(string value)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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)
			int num = ((!string.IsNullOrWhiteSpace(value)) ? value.Trim().Length : 0);
			if ((num == 6 || num == 7) && TryParseHexColor(value, out var color))
			{
				_brushColor = color;
				_colorPicker?.SetColor(_brushColor, notify: false);
				if ((Object)(object)_colorSwatch != (Object)null)
				{
					((Graphic)_colorSwatch).color = _brushColor;
				}
				UpdateBrushIndicator();
			}
		}

		private void ApplyHexInput(string value)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			if (TryParseHexColor(value, out var color))
			{
				_brushColor = color;
				_colorPicker?.SetColor(_brushColor, notify: false);
				UpdateColorUi();
				DrawableSuitsDiagnostics.Info("Applied brush color from hex input. input=" + value + "; color=" + ColorToHex(_brushColor));
				return;
			}
			SetStatus("Invalid hex color", warn: false);
			if ((Object)(object)_colorHexInput != (Object)null)
			{
				_colorHexInput.SetTextWithoutNotify(ColorToHex(_brushColor));
			}
			DrawableSuitsDiagnostics.Warn("Invalid brush color hex input ignored. input=" + value);
		}

		private static string ColorToHex(Color color)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.RoundToInt(Mathf.Clamp01(color.r) * 255f);
			int num2 = Mathf.RoundToInt(Mathf.Clamp01(color.g) * 255f);
			int num3 = Mathf.RoundToInt(Mathf.Clamp01(color.b) * 255f);
			return $"#{num:X2}{num2:X2}{num3:X2}";
		}

		private static bool TryParseHexColor(string value, out Color color)
		{
			//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_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			color = Color.white;
			if (string.IsNullOrWhiteSpace(value))
			{
				return false;
			}
			string text = value.Trim();
			if (text.StartsWith("#", StringComparison.Ordinal))
			{
				text = text.Substring(1);
			}
			if (text.Length != 6 || !int.TryParse(text, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var result))
			{
				return false;
			}
			color = new Color((float)((result >> 16) & 0xFF) / 255f, (float)((result >> 8) & 0xFF) / 255f, (float)(result & 0xFF) / 255f, 1f);
			return true;
		}

		private void LoadRecentColors()
		{
			_recentColors.Clear();
			int num = 0;
			string text = DrawableSuitsPlugin.ModConfig?.RecentColors?.Value;
			if (!string.IsNullOrWhiteSpace(text))
			{
				string[] array = text.Split(new char[6] { ',', ';', ' ', '\n', '\r', '\t' }, StringSplitOptions.RemoveEmptyEntries);
				for (int i = 0; i < array.Length; i++)
				{
					if (_recentColors.Count >= 12)
					{
						break;
					}
					if (TryNormalizeHexColor(array[i], out var normalized))
					{
						if (!_recentColors.Contains(normalized))
						{
							_recentColors.Add(normalized);
						}
					}
					else
					{
						num++;
					}
				}
			}
			DrawableSuitsDiagnostics.Info($"RecentColorsLoaded: count={_recentColors.Count}; ignoredInvalid={num}; rawLength={(text ?? string.Empty).Length}");
		}

		private static bool TryNormalizeHexColor(string value, out string normalized)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			normalized = string.Empty;
			if (!TryParseHexColor(value, out var color))
			{
				return false;
			}
			normalized = ColorToHex(color);
			return true;
		}

		private void SaveRecentColors()
		{
			if (DrawableSuitsPlugin.ModConfig?.RecentColors != null)
			{
				DrawableSuitsPlugin.ModConfig.RecentColors.Value = string.Join(",", _recentColors.ToArray());
			}
		}

		private void AddRecentColorFromBrush(string sourceAction)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (!TryNormalizeHexColor(ColorToHex(_brushColor), out var normalized))
			{
				return;
			}
			int num = _recentColors.IndexOf(normalized);
			bool flag = num >= 0;
			if (num != 0)
			{
				if (flag)
				{
					_recentColors.RemoveAt(num);
				}
				_recentColors.Insert(0, normalized);
				while (_recentColors.Count > 12)
				{
					_recentColors.RemoveAt(_recentColors.Count - 1);
				}
				SaveRecentColors();
				UpdateRecentColorSwatches();
				DrawableSuitsDiagnostics.Info($"RecentColorAdded: color={normalized}; source={sourceAction}; duplicate={flag}; slotCount={_recentColors.Count}");
			}
		}

		private void SelectRecentColor(int index)
		{
			//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_0055: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 0 && index < _recentColors.Count)
			{
				string text = _recentColors[index];
				if (!TryParseHexColor(text, out var color))
				{
					DrawableSuitsDiagnostics.Warn($"RecentColorSelected ignored invalid stored color. index={index}; color={text}");
					return;
				}
				_brushColor = color;
				_colorPicker?.SetColor(_brushColor, notify: false);
				UpdateColorUi();
				SetStatus("Selected recent color " + text + ".", warn: false);
				DrawableSuitsDiagnostics.Info($"RecentColorSelected: color={text}; index={index}; slotCount={_recentColors.Count}");
			}
		}

		private void UpdateRecentColorSwatches()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: 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)
			for (int i = 0; i < _recentColorButtons.Count; i++)
			{
				Button val = _recentColorButtons[i];
				Image val2 = ((i < _recentColorImages.Count) ? _recentColorImages[i] : null);
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null))
				{
					Color color = Color.white;
					bool flag = (((Selectable)val).interactable = i < _recentColors.Count && TryParseHexColor(_recentColors[i], out color));
					((Graphic)val2).color = (flag ? color : TerminalInputColor);
					ColorBlock colors = ((Selectable)val).colors;
					((ColorBlock)(ref colors)).normalColor = ((Graphic)val2).color;
					((ColorBlock)(ref colors)).highlightedColor = (flag ? Color.Lerp(((Graphic)val2).color, Color.white, 0.28f) : ((Graphic)val2).color);
					((ColorBlock)(ref colors)).pressedColor = (flag ? Color.Lerp(((Graphic)val2).color, Color.black, 0.2f) : ((Graphic)val2).color);
					((ColorBlock)(ref colors)).selectedColor = ((ColorBlock)(ref colors)).normalColor;
					((Selectable)val).colors = colors;
				}
			}
			if ((Object)(object)_recentColorsLabel != (Object)null)
			{
				((Component)_recentColorsLabel).gameObject.SetActive(true);
			}
		}

		private void UpdateToolButtons()
		{
			SetToolButtonColor(_paintButton, _tool == EditorTool.Paint);
			SetToolButtonColor(_eraseButton, _tool == EditorTool.Erase);
			SetToolButtonColor(_fillButton, _tool == EditorTool.FillBucket);
			SetToolButtonColor(_decalButton, _tool == EditorTool.Decal);
			SetToolButtonColor(_eyedropperButton, _tool == EditorTool.Eyedropper);
			SetToolButtonColor(_textButton, _tool == EditorTool.Text);
			SetToolButtonColor(_stickerButton, _tool == EditorTool.Sticker);
			SetToolButtonColor(_mirrorButton, _mirrorEnabled);
			if ((Object)(object)_activeToolLabel != (Object)null)
			{
				_activeToolLabel.text = (_mirrorEnabled ? ("Active: " + ToolDisplayName(_tool) + " | Mirror") : ("Active: " + ToolDisplayName(_tool)));
			}
			UpdateBrushShapeButton();
			UpdateStickerShapeButton();
		}

		private void UpdateBrushShapeButton()
		{
			if ((Object)(object)_brushShapeButton != (Object)null)
			{
				SetButtonLabel(_brushShapeButton, BrushShapeDisplayName(_brushShape));
			}
			for (int i = 0; i < _brushShapeOptionButtons.Count; i++)
			{
				Button val = _brushShapeOptionButtons[i];
				if (!((Object)(object)val == (Object)null))
				{
					BrushShape[] array = (BrushShape[])Enum.GetValues(typeof(BrushShape));
					bool selected = i < array.Length && array[i] == _brushShape;
					SetToolButtonColor(val, selected);
				}
			}
		}

		private static void SetToolButtonColor(Button button, bool selected)
		{
			//IL_0034: 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_0039: 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_0056: 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_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_0088: 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_0073: 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_0096: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)button == (Object)null))
			{
				Image component = ((Component)button).GetComponent<Image>();
				Color val = (Color)(((Selectable)button).interactable ? TerminalButtonColor : new Color(0.04f, 0.02f, 0.02f, 0.72f));
				Color val2 = (Color)(((Selectable)button).interactable ? TerminalAccentColor : new Color(0.16f, 0.035f, 0.03f, 0.72f));
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = (selected ? val2 : val);
				}
				ColorBlock colors = ((Selectable)button).colors;
				((ColorBlock)(ref colors)).normalColor = (selected ? val2 : val);
				((ColorBlock)(ref colors)).highlightedColor = (selected ? TerminalAccentHotColor : val);
				((ColorBlock)(ref colors)).selectedColor = ((ColorBlock)(ref colors)).normalColor;
				((ColorBlock)(ref colors)).pressedColor = TerminalButtonPressedColor;
				((Selectable)button).colors = colors;
				Color val3 = (Color)((!((Selectable)button).interactable) ? new Color(0.38f, 0.28f, 0.25f, 0.9f) : (selected ? TerminalTextColor : new Color(0.88f, 0.34f, 0.24f, 1f)));
				Transform val4 = ((Component)button).transform.Find("Icon");
				RawImage val5 = (((Object)(object)val4 != (Object)null) ? ((Component)val4).GetComponent<RawImage>() : null);
				if ((Object)(object)val5 != (Object)null)
				{
					((Graphic)val5).color = val3;
				}
				DrawableToolIconGraphic drawableToolIconGraphic = (((Object)(object)val4 != (Object)null) ? ((Component)val4).GetComponent<DrawableToolIconGraphic>() : null);
				if ((Object)(object)drawableToolIconGraphic != (Object)null)
				{
					drawableToolIconGraphic.SetIconColor(val3);
				}
			}
		}

		private static string ToolDisplayName(EditorTool tool)
		{
			return tool switch
			{
				EditorTool.Paint => "Paint", 
				EditorTool.Erase => "Erase", 
				EditorTool.FillBucket => "Fill", 
				EditorTool.Decal => "Decal", 
				EditorTool.Eyedropper => "Eyedropper", 
				EditorTool.Text => "Text", 
				EditorTool.Sticker => "Sticker", 
				_ => tool.ToString(), 
			};
		}

		private void SetTool(EditorTool tool)
		{
			HideBrushShapeMenu();
			if (tool != EditorTool.Sticker)
			{
				HideStickerShapeMenu();
			}
			if (tool == EditorTool.Eyedropper)
			{
				_previousToolBeforeEyedropper = (IsReturnableEyedropperTool(_tool) ? _tool : EditorTool.Paint);
			}
			if (tool == EditorTool.Decal && (Object)(object)_loadedDecal == (Object)null)
			{
				WarnMissingDecal("tool selection");
				_tool = EditorTool.Paint;
				HideDecalPlacementPreview("decal tool missing decal", forceLog: false);
				UpdateToolButtons();
				UpdateBrushIndicator();
				return;
			}
			_tool = tool;
			_decalStampArmed = true;
			_suppressPaintInputUntilRelease = false;
			_suppressDecalPreviewUntilRelease = false;
			if (tool == EditorTool.Decal || tool == EditorTool.Sticker)
			{
				InvalidateDecalPreview($"{tool} tool selected");
			}
			else
			{
				HideDecalPlacementPreview("tool changed", forceLog: false);
			}
			if (tool == EditorTool.Text && string.IsNullOrWhiteSpace(_textStampValue))
			{
				SetStatus("Enter text before stamping.", warn: false);
			}
			if (tool != EditorTool.Decal && _statusMessage.StartsWith("Select a decal", StringComparison.OrdinalIgnoreCase))
			{
				SetStatus(BuildReadinessStatus(), warn: false);
			}
			if (tool == EditorTool.Eyedropper)
			{
				SetStatus("Eyedropper active. Aim at the suit to sample a color.", warn: false);
			}
			if (tool == EditorTool.Sticker)
			{
				SetStatus("Sticker active: " + StickerShapeDisplayName(_stickerShape) + ". Click/RT to stamp.", warn: false);
			}
			if (tool == EditorTool.FillBucket)
			{
				SetStatus("Fill active. Click or RT a matching color region to fill.", warn: false);
			}
			UpdateToolButtons();
			UpdatePlacementControlsForTool();
			UpdateLabels();
			UpdateBrushIndicator();
		}

		private static bool IsReturnableEyedropperTool(EditorTool tool)
		{
			if (tool != EditorTool.Paint && tool != EditorTool.Erase && tool != EditorTool.FillBucket && tool != EditorTool.Decal && tool != EditorTool.Text)
			{
				return tool == EditorTool.Sticker;
			}
			return true;
		}

		private void UpdatePlacementControlsForTool()
		{
			if ((Object)(object)_decalSizeSlider != (Object)null)
			{
				_decalSizeSlider.SetValue(CurrentPlacementSize(), notify: false);
			}
			if ((Object)(object)_decalRotationSlider != (Object)null)
			{
				_decalRotationSlider.SetValue(CurrentPlacementRotation(), notify: false);
			}
			UpdateLabels();
		}

		private void ToggleMirror()
		{
			_mirrorEnabled = !_mirrorEnabled;
			_decalStampArmed = true;
			_suppressDecalPreviewUntilRelease = false;
			InvalidateDecalPreview("mirror toggled");
			if (!_mirrorEnabled && (Object)(object)_uvMirrorDecalPreviewRect != (Object)null)
			{
				((Component)_uvMirrorDecalPreviewRect).gameObject.SetActive(false);
			}
			SetStatus(_mirrorEnabled ? "Mirror enabled. Edits duplicate on the opposite suit surface." : "Mirror disabled.", warn: false);
			UpdateToolButtons();
			DrawableSuitsDiagnostics.Info($"Mirror painting toggled. enabled={_mirrorEnabled}; tool={_tool}; suit={_selectedSuitId}; previewMode={_previewMode}");
		}

		private void ToggleBrushShapeMenu()
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_brushShapeMenuObject == (Object)null)
			{
				return;
			}
			bool flag = !_brushShapeMenuObject.activeSelf;
			_brushShapeMenuObject.SetActive(flag);
			if (flag)
			{
				_brushShapeMenuObject.transform.SetAsLastSibling();
				GameObject canvasCursorObject = _canvasCursorObject;
				if (canvasCursorObject != null)
				{
					canvasCursorObject.transform.SetAsLastSibling();
				}
			}
			DrawableSuitsDiagnostics.Info($"Brush shape dropdown toggled. open={flag}; shape={_brushShape}; tool={_tool}; cursor={_cursor}");
		}

		private void HideBrushShapeMenu()
		{
			if ((Object)(object)_brushShapeMenuObject != (Object)null && _brushShapeMenuObject.activeSelf)
			{
				_brushShapeMenuObject.SetActive(false);
			}
		}

		private void SelectBrushShape(BrushShape shape)
		{
			_brushShape = shape;
			HideBrushShapeMenu();
			UpdateBrushShapeButton();
			UpdateLabels();
			UpdateCanvasCursor(force: true, "brush shape changed");
			DrawableSuitsDiagnostics.Info($"Brush shape selected. shape={_brushShape}; tool={_tool}; brushSize={_brushSize:0.#}; suit={_selectedSuitId}");
		}

		private void ToggleStickerShapeMenu()
		{
			OpenStickersPanel();
		}

		private void HideStickerShapeMenu()
		{
			if ((Object)(object)_stickerShapeMenuObject != (Object)null && _stickerShapeMenuObject.activeSelf)
			{
				_stickerShapeMenuObject.SetActive(false);
			}
		}

		private void UpdateStickerShapeButton()
		{
			if ((Object)(object)_stickerShapeButton != (Object)null)
			{
				SetButtonLabel(_stickerShapeButton, "Stickers");
			}
			if ((Object)(object)_selectedStickerShapeLabel != (Object)null)
			{
				_selectedStickerShapeLabel.text = StickerShapeDisplayName(_stickerShape);
			}
			StickerShape[] array = (StickerShape[])Enum.GetValues(typeof(StickerShape));
			for (int i = 0; i < _stickerShapeOptionButtons.Count; i++)
			{
				Button val = _stickerShapeOptionButtons[i];
				if (!((Object)(object)val == (Object)null))
				{
					bool selected = i < array.Length && array[i] == _stickerShape;
					SetToolButtonColor(val, selected);
				}
			}
			for (int j = 0; j < _stickerPanelShapeButtons.Count; j++)
			{
				Button val2 = _stickerPanelShapeButtons[j];
				if (!((Object)(object)val2 == (Object)null))
				{
					bool selected2 = j < array.Length && array[j] == _stickerShape;
					SetToolButtonColor(val2, selected2);
				}
			}
		}

		private void SelectStickerShape(StickerShape shape)
		{
			bool num = _stickerShape != shape;
			_stickerShape = shape;
			HideStickerShapeMenu();
			CloseStickersPanel();
			if (num)
			{
				ResetPlacementEdit(PlacementEditTarget.Sticker, "sticker shape changed", log: true);
			}
			UpdateStickerShapeButton();
			InvalidateDecalPreview("sticker shape changed");
			SetStatus("Sticker shape: " + StickerShapeDisplayName(_stickerShape) + ".", warn: false);
			DrawableSuitsDiagnostics.Info($"StickerShapeSelected: shape={_stickerShape}; display={StickerShapeDisplayName(_stickerShape)}; tool={_tool}; size={_stickerSize:0.#}; rotation={_stickerRotation:0.#}; suit={_selectedSuitId}");
		}

		private static string BrushShapeDisplayName(BrushShape shape)
		{
			return shape switch
			{
				BrushShape.Circle => "Circle", 
				BrushShape.Square => "Square", 
				BrushShape.Pixel => "Pixel", 
				BrushShape.SprayPaint => "Spray Paint", 
				BrushShape.SoftAirbrush => "Soft Airbrush", 
				BrushShape.NoiseScatter => "Noise/Scatter", 
				_ => shape.ToString(), 
			};
		}

		private static string StickerShapeDisplayName(StickerShape shape)
		{
			return shape switch
			{
				StickerShape.Circle => "Circle", 
				StickerShape.Square => "Square", 
				StickerShape.Triangle => "Triangle", 
				StickerShape.Diamond => "Diamond", 
				StickerShape.Star => "Star", 
				StickerShape.Heart => "Heart", 
				StickerShape.Arrow => "Arrow", 
				StickerShape.LightningBolt => "Lightning Bolt", 
				StickerShape.Plus => "Plus/Cross", 
				StickerShape.Ring => "Ring", 
				StickerShape.Crescent => "Crescent", 
				StickerShape.Shield => "Shield", 
				_ => shape.ToString(), 
			};
		}

		private static string StickerShapeShortName(StickerShape shape)
		{
			return shape switch
			{
				StickerShape.LightningBolt => "Bolt", 
				StickerShape.Plus => "Plus", 
				_ => StickerShapeDisplayName(shape), 
			};
		}

		private void CycleTool()
		{
			if (_tool == EditorTool.Paint)
			{
				SetTool(EditorTool.Erase);
			}
			else if (_tool == EditorTool.Erase)
			{
				SetTool(((Object)(object)_loadedDecal != (Object)null) ? EditorTool.Decal : EditorTool.Paint);
			}
			else
			{
				SetTool(EditorTool.Paint);
			}
		}

		private void EnsureValidToolForCurrentState(string context)
		{
			if (_tool == EditorTool.Decal && !((Object)(object)_loadedDecal != (Object)null))
			{
				_tool = EditorTool.Paint;
				SetStatus("Ready. Paint is selected because no decal is loaded.", warn: false);
				UpdateToolButtons();
				DrawableSuitsDiagnostics.Info("Tool reset to Paint. context=" + context + "; reason=no loaded decal");
			}
		}

		private void WarnMissingDecal(string context)
		{
			SetStatus("Select a decal before using Decal. Paint mode is active until a decal is selected.", warn: false);
			if (Time.unscaledTime - _lastMissingDecalWarningTime > 0.75f)
			{
				_lastMissingDecalWarningTime = Time.unscaledTime;
				DrawableSuitsDiagnostics.Warn($"Decal tool unavailable because no decal is loaded. context={context}; decalCount={_decalFiles.Count}; selectedDecalIndex={_selectedDecalIndex}");
			}
		}

		private void RefreshListButtons()
		{
			if ((Object)(object)_designListContent != (Object)null)
			{
				UpdateAnchoredList(_designListContent, _designFiles, _selectedDesignIndex, ref _designListPage, "Design", _designRows, ref _designEmptyLabel, ref _designPrevPageButton, ref _designNextPageButton, ref _designPageLabel, delegate(int index)
				{
					CancelPendingDesignDelete("design selection changed");
					_selectedDesignIndex = index;
					RefreshListButtons();
					UpdateUiState();
					SetSavedDesignsStatus("Selected " + Path.GetFileNameWithoutExtension(_designFiles[index]) + ".");
					DrawableSuitsDiagnostics.Info(string.Format("Design row selected. index={0}; file={1}", index, (_designFiles.Count > index) ? _designFiles[index] : "missing"));
				}, (string path) => Path.GetFileNameWithoutExtension(path));
			}
			if ((Object)(object)_decalListContent != (Object)null)
			{
				UpdateAnchoredList(_decalListContent, _decalFiles, _selectedDecalIndex, ref _decalListPage, "Decal", _decalRows, ref _decalEmptyLabel, ref _decalPrevPageButton, ref _decalNextPageButton, ref _decalPageLabel, SelectDecal, Path.GetFileName);
			}
			RebuildSelectableNavigation();
		}

		private void UpdateAnchoredList(RectTransform content, List<string> files, int selectedIndex, ref int page, string listName, List<AnchoredListRow> rowPool, ref Text emptyLabel, ref Button prevPageButton, ref Button nextPageButton, ref Text pageLabel, Action<int> onSelect, Func<string, string> labelSelector)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Expected O, but got Unknown
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0492: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_042c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Expected O, but got Unknown
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Expected O, but got Unknown
			Rect rect = content.rect;
			float num = 30f;
			float num2 = 4f;
			int num3 = Mathf.Max(1, Mathf.FloorToInt((((Rect)(ref rect)).height - 34f) / (num + num2)));
			if (files.Count <= num3)
			{
				num3 = Mathf.Max(1, Mathf.FloorToInt(((Rect)(ref rect)).height / (num + num2)));
			}
			int num4 = Mathf.Max(0, Mathf.CeilToInt((float)files.Count / (float)num3) - 1);
			page = Mathf.Clamp(page, 0, num4);
			int num5 = page * num3;
			int num6 = Mathf.Min(files.Count, num5 + num3);
			EnsureAnchoredListPool(content, listName, rowPool, num3, num, num2);
			EnsureAnchoredListEmptyLabel(content, listName, ref emptyLabel);
			EnsureAnchoredListPager(content, listName, ref prevPageButton, ref nextPageButton, ref pageLabel);
			DisableLegacyListChildren(content, rowPool, emptyLabel, prevPageButton, nextPageButton, pageLabel);
			if ((Object)(object)emptyLabel != (Object)null)
			{
				emptyLabel.text = ((listName == "Decal") ? "No decals found" : "No saved designs");
				((Component)emptyLabel).gameObject.SetActive(files.Count == 0);
				SetAnchoredRect(((Component)emptyLabel).GetComponent<RectTransform>(), new Rect(8f, 8f, ((Rect)(ref rect)).width - 16f, 26f));
			}
			for (int i = 0; i < rowPool.Count; i++)
			{
				AnchoredListRow anchoredListRow = rowPool[i];
				int num7 = num5 + i;
				bool flag = num7 < num6;
				if ((Object)(object)anchoredListRow?.Button == (Object)null)
				{
					continue;
				}
				((Component)anchoredListRow.Button).gameObject.SetActive(flag);
				anchoredListRow.Index = (flag ? num7 : (-1));
				((UnityEventBase)anchoredListRow.Button.onClick).RemoveAllListeners();
				if (flag)
				{
					int index = num7;
					float num8 = 6f + (float)i * (num + num2);
					SetAnchoredRect(((Component)anchoredListRow.Button).GetComponent<RectTransform>(), new Rect(6f, num8, ((Rect)(ref rect)).width - 12f, num));
					string label = labelSelector(files[index]);
					SetButtonLabel(anchoredListRow.Button, TruncateListLabel(label));
					((UnityEvent)anchoredListRow.Button.onClick).AddListener((UnityAction)delegate
					{
						onSelect(index);
						ClearSelectedNormalButton();
					});
					if (index == selectedIndex)
					{
						ApplySelectedListButtonStyle(anchoredListRow.Button);
					}
					else
					{
						ApplyNormalListButtonStyle(anchoredListRow.Button);
					}
				}
			}
			bool active = num4 > 0;
			int currentPage = page;
			int currentMaxPage = num4;
			if ((Object)(object)prevPageButton != (Object)null)
			{
				((Component)prevPageButton).gameObject.SetActive(active);
				SetAnchoredRect(((Component)prevPageButton).GetComponent<RectTransform>(), new Rect(6f, Mathf.Max(6f, ((Rect)(ref rect)).height - 32f), 42f, 26f));
				((UnityEventBase)prevPageButton.onClick).RemoveAllListeners();
				((UnityEvent)prevPageButton.onClick).AddListener((UnityAction)delegate
				{
					CancelPendingListDelete(listName, "list page changed");
					SetListPage(listName, Mathf.Max(0, currentPage - 1));
					RefreshListButtons();
					ClearSelectedNormalButton();
				});
			}
			if ((Object)(object)pageLabel != (Object)null)
			{
				((Component)pageLabel).gameObject.SetActive(active);
				pageLabel.text = $"{page + 1}/{num4 + 1}";
				SetAnchoredRect(((Component)pageLabel).GetComponent<RectTransform>(), new Rect(54f, Mathf.Max(6f, ((Rect)(ref rect)).height - 32f), 64f, 26f));
			}
			if ((Object)(object)nextPageButton != (Object)null)
			{
				((Component)nextPageButton).gameObject.SetActive(active);
				SetAnchoredRect(((Component)nextPageButton).GetComponent<RectTransform>(), new Rect(124f, Mathf.Max(6f, ((Rect)(ref rect)).height - 32f), 42f, 26f));
				((UnityEventBase)nextPageButton.onClick).RemoveAllListeners();
				((UnityEvent)nextPageButton.onClick).AddListener((UnityAction)delegate
				{
					CancelPendingListDelete(listName, "list page changed");
					SetListPage(listName, Mathf.Min(currentMaxPage, currentPage + 1));
					RefreshListButtons();
					ClearSelectedNormalButton();
				});
			}
			DrawableSuitsDiagnostics.Info($"ListRowsUpdated name={listName}; fileCount={files.Count}; selected={selectedIndex}; page={page}; maxPage={num4}; visibleRows={num3}; pooledRows={rowPool.Count}; rect={rect}; childCount={((Transform)content).childCount}");
		}

		private void EnsureAnchoredListPool(RectTransform content, string listName, List<AnchoredListRow> rowPool, int rows, float rowHeight, float spacing)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			while (rowPool.Count < rows)
			{
				int count = rowPool.Count;
				float num = 6f + (float)count * (rowHeight + spacing);
				string text = listName + "Row";
				Rect rect = content.rect;
				Button val = CreateAnchoredButton((Transform)(object)content, text, new Rect(6f, num, ((Rect)(ref rect)).width - 12f, rowHeight), null);
				((Object)val).name = $"{listName}RowSlot{count}";
				((UnityEventBase)val.onClick).RemoveAllListeners();
				ApplyNormalListButtonStyle(val);
				rowPool.Add(new AnchoredListRow
				{
					Button = val,
					Label = ((Component)val).GetComponentInChildren<Text>(true),
					Image = ((Component)val).GetComponent<Image>(),
					Index = -1
				});
			}
			for (int i = rows; i < rowPool.Count; i++)
			{
				if ((Object)(object)rowPool[i]?.Button != (Object)null)
				{
					((UnityEventBase)rowPool[i].Button.onClick).RemoveAllListeners();
					((Component)rowPool[i].Button).gameObject.SetActive(false);
					rowPool[i].Index = -1;
				}
			}
		}

		private void EnsureAnchoredListEmptyLabel(RectTransform content, string listName, ref Text emptyLabel)
		{
			//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_0044: 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)
			if (!((Object)(object)emptyLabel != (Object)null))
			{
				string name = listName + "Empty";
				string empty = string.Empty;
				Rect rect = content.rect;
				emptyLabel = CreateAnchoredText((Transform)(object)content, name, empty, 13, (FontStyle)0, (TextAnchor)3, new Rect(8f, 8f, ((Rect)(ref rect)).width - 16f, 26f), new Color(0.76f, 0.78f, 0.82f, 1f));
				((Component)emptyLabel).gameObject.SetActive(false);
			}
		}

		private void EnsureAnchoredListPager(RectTransform content, string listName, ref Button prevPageButton, ref Button nextPageButton, ref Text pageLabel)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0104: Unknown result type (might be due to invalid IL or missing references)
			Rect rect;
			if ((Object)(object)prevPageButton == (Object)null)
			{
				rect = content.rect;
				prevPageButton = CreateAnchoredButton((Transform)(object)content, "<", new Rect(6f, ((Rect)(ref rect)).height - 32f, 42f, 26f), null);
				((Object)prevPageButton).name = listName + "PrevPageButton";
				((UnityEventBase)prevPageButton.onClick).RemoveAllListeners();
				((Component)prevPageButton).gameObject.SetActive(false);
			}
			if ((Object)(object)pageLabel == (Object)null)
			{
				string name = listName + "Page";
				string empty = string.Empty;
				rect = content.rect;
				pageLabel = CreateAnchoredText((Transform)(object)content, name, empty, 12, (FontStyle)0, (TextAnchor)4, new Rect(54f, ((Rect)(ref rect)).height - 32f, 64f, 26f), TerminalTextColor);
				((Component)pageLabel).gameObject.SetActive(false);
			}
			if ((Object)(object)nextPageButton == (Object)null)
			{
				rect = content.rect;
				nextPageButton = CreateAnchoredButton((Transform)(object)content, ">", new Rect(124f, ((Rect)(ref rect)).height - 32f, 42f, 26f), null);
				((Object)nextPageButton).name = listName + "NextPageButton";
				((UnityEventBase)nextPageButton.onClick).RemoveAllListeners();
				((Component)nextPageButton).gameObject.SetActive(false);
			}
		}

		private static void DisableLegacyListChildren(RectTransform content, List<AnchoredListRow> rowPool, Text emptyLabel, Button prevPageButton, Button nextPageButton, Text pageLabel)
		{
			for (int num = ((Transform)content).childCount - 1; num >= 0; num--)
			{
				Transform child = ((Transform)content).GetChild(num);
				GameObject val = (((Object)(object)child != (Object)null) ? ((Component)child).gameObject : null);
				if (!((Object)(object)val == (Object)null) && !IsKnownListChild(val, rowPool, emptyLabel, prevPageButton, nextPageButton, pageLabel))
				{
					DisableRaycastsAndSelectables(val);
					val.SetActive(false);
					Object.Destroy((Object)(object)val);
				}
			}
		}

		private static bool IsKnownListChild(GameObject go, List<AnchoredListRow> rowPool, Text emptyLabel, Button prevPageButton, Button nextPageButton, Text pageLabel)
		{
			if ((Object)(object)emptyLabel != (Object)null && (Object)(object)go == (Object)(object)((Component)emptyLabel).gameObject)
			{
				return true;
			}
			if ((Object)(object)prevPageButton != (Object)null && (Object)(object)go == (Object)(object)((Component)prevPageButton).gameObject)
			{
				return true;
			}
			if ((Object)(object)nextPageButton != (Object)null && (Object)(object)go == (Object)(object)((Component)nextPageButton).gameObject)
			{
				return true;
			}
			if ((Object)(object)pageLabel != (Object)null && (Object)(object)go == (Object)(object)((Component)pageLabel).gameObject)
			{
				return true;
			}
			for (int i = 0; i < rowPool.Count; i++)
			{
				if ((Object)(object)rowPool[i]?.Button != (Object)null && (Object)(object)go == (Object)(object)((Component)rowPool[i].Button).gameObject)
				{
					return true;
				}
			}
			return false;
		}

		private static void DisableRaycastsAndSelectables(GameObject go)
		{
			Selectable[] componentsInChildren = go.GetComponentsInChildren<Selectable>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if ((Object)(object)componentsInChildren[i] != (Object)null)
				{
					componentsInChildren[i].interactable = false;
				}
			}
			Graphic[] componentsInChildren2 = go.GetComponentsInChildren<Graphic>(true);
			for (int j = 0; j < componentsInChildren2.Length; j++)
			{
				if ((Object)(object)componentsInChildren2[j] != (Object)null)
				{
					componentsInChildren2[j].raycastTarget = false;
				}
			}
		}

		private void SetListPage(string listName, int page)
		{
			if (string.Equals(listName, "Design", StringComparison.OrdinalIgnoreCase))
			{
				_designListPage = page;
			}
			else
			{
				_decalListPage = page;
			}
		}

		private static string TruncateListLabel(string label)
		{
			if (string.IsNullOrWhiteSpace(label))
			{
				return "(unnamed)";
			}
			if (label.Length > 28)
			{
				return label.Substring(0, 25) + "...";
			}
			return label;
		}

		private static void ApplySelectedListButtonStyle(Button button)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)button == (Object)null))
			{
				Image component = ((Component)button).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = TerminalAccentColor;
				}
				ColorBlock colors = ((Selectable)button).colors;
				((ColorBlock)(ref colors)).normalColor = TerminalAccentColor;
				((ColorBlock)(ref colors)).highlightedColor = TerminalAccentHotColor;
				((ColorBlock)(ref colors)).selectedColor = ((ColorBlock)(ref colors)).highlightedColor;
				((ColorBlock)(ref colors)).pressedColor = TerminalButtonPressedColor;
				((Selectable)button).colors = colors;
			}
		}

		private static void ApplyNormalListButtonStyle(Button button)
		{
			//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_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_0030: 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_0040: 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_0053: 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)
			if (!((Object)(object)button == (Object)null))
			{
				Color terminalButtonColor = TerminalButtonColor;
				Image component = ((Component)button).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = terminalButtonColor;
				}
				ColorBlock colors = ((Selectable)button).colors;
				((ColorBlock)(ref colors)).normalColor = terminalButtonColor;
				((ColorBlock)(ref colors)).highlightedColor = terminalButtonColor;
				((ColorBlock)(ref colors)).selectedColor = terminalButtonColor;
				((ColorBlock)(ref colors)).pressedColor = TerminalButtonPressedColor;
				((Selectable)button).colors = colors;
			}
		}

		private void RebuildSelectableNavigation()
		{
			//IL_005b: 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_00dd: 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)
			if ((Object)(object)_panelRect == (Object)null)
			{
				return;
			}
			List<Selectable> list = new List<Selectable>();
			Selectable[] componentsInChildren = ((Component)_panelRect).GetComponentsInChildren<Selectable>(true);
			foreach (Selectable val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && ((Component)val).gameObject.activeInHierarchy)
				{
					list.Add(val);
				}
			}
			for (int j = 0; j < list.Count; j++)
			{
				Navigation val2 = default(Navigation);
				((Navigation)(ref val2)).mode = (Mode)4;
				((Navigation)(ref val2)).selectOnUp = ((j > 0) ? list[j - 1] : null);
				((Navigation)(ref val2)).selectOnDown = ((j < list.Count - 1) ? list[j + 1] : null);
				((Navigation)(ref val2)).selectOnLeft = ((j > 0) ? list[j - 1] : null);
				((Navigation)(ref val2)).selectOnRight = ((j < list.Count - 1) ? list[j + 1] : null);
				Navigation navigation = val2;
				list[j].navigation = navigation;
			}
			ClearSelectedNormalButton();
		}

		private void DrawImmediateCursor()
		{
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			if (!_isOpen)
			{
				LogImmediateCursorDrawSkipped("editor closed");
				return;
			}
			CursorVisualMode cursorVisualMode = CursorVisualMode.Dot;
			float num = 9f;
			Color color = Color.white;
			string targetMode = "Navigation";
			int triangleIndex = -1;
			Vector2 uv = Vector2.zero;
			string fallbackReason = string.Empty;
			if (TryResolveBrushCursor(out var diameter, out var color2, out targetMode, out triangleIndex, out uv, out fallbackReason))
			{
				cursorVisualMode = CursorVisualModeForBrushShape(_brushShape);
				num = ClampCursorDiameter(diameter);
				color = color2;
			}
			Texture2D val = ((cursorVisualMode == CursorVisualMode.BrushRing) ? EnsureCursorRingTexture() : EnsureCursorDotTexture());
			if ((Object)(object)val == (Object)null)
			{
				LogImmediateCursorDrawSkipped($"missing texture mode={cursorVisualMode}");
				return;
			}
			float num2 = Mathf.Clamp(_cursor.x, 0f, (float)Screen.width);
			float num3 = Mathf.Clamp(_cursor.y, 0f, (float)Screen.height);
			Vector2 center = new Vector2(num2, (float)Screen.height - num3);
			float size = ((cursorVisualMode == CursorVisualMode.BrushRing) ? num : 9f);
			float size2 = ((cursorVisualMode == CursorVisualMode.BrushRing) ? (num + 6f) : 15f);
			Rect val2 = RectFromCenter(center, size);
			Rect val3 = RectFromCenter(center, size2);
			int depth = GUI.depth;
			Color color3 = GUI.color;
			try
			{
				GUI.depth = int.MinValue;
				GUI.color = ((cursorVisualMode == CursorVisualMode.BrushRing) ? new Color(0f, 0f, 0f, 0.95f) : new Color(0f, 0f, 0f, 0.85f));
				GUI.DrawTexture(val3, (Texture)(object)val, (ScaleMode)0, true);
				GUI.color = color;
				GUI.DrawTexture(val2, (Texture)(object)val, (ScaleMode)0, true);
			}
			finally
			{
				GUI.color = color3;
				GUI.depth = depth;
			}
			LogImmediateCursorUpdated(cursorVisualMode, targetMode, num, triangleIndex, uv, fallbackReason, val2, val);
		}

		private void EnsureCanvasCursor()
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_editorCanvasObject == (Object)null) && !((Object)(object)_canvasRect == (Object)null) && (!((Object)(object)_canvasCursorObject != (Object)null) || !((Object)(object)_canvasCursorRect != (Object)null) || !((Object)(object)_canvasCursorGraphic != (Object)null)))
			{
				DestroyCanvasCursor("rebuild");
				_canvasCursorObject = CreateUiObject("DrawableSuitsCanvasCursor", _editorCanvasObject.transform, typeof(RectTransform), typeof(DrawableCanvasCursorGraphic));
				_canvasCursorRect = _canvasCursorObject.GetComponent<RectTransform>();
				_canvasCursorRect.anchorMin = new Vector2(0.5f, 0.5f);
				_canvasCursorRect.anchorMax = new Vector2(0.5f, 0.5f);
				_canvasCursorRect.pivot = new Vector2(0.5f, 0.5f);
				_canvasCursorRect.anchoredPosition = Vector2.zero;
				_canvasCursorRect.sizeDelta = new Vector2(17f, 17f);
				_canvasCursorGraphic = _canvasCursorObject.GetComponent<DrawableCanvasCursorGraphic>();
				((Graphic)_canvasCursorGraphic).raycastTarget = false;
				_canvasCursorGraphic.SetVisual(CursorVisualMode.Dot, Color.white, 15f);
				_canvasCursorObject.SetActive(false);
				LogCanvasCursorBuilt("created");
			}
		}

		private void UpdateCanvasCursor(bool force, string context)
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: 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_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			if (!_isOpen)
			{
				HideCanvasCursor("update while closed " + context, forceLog: false);
				return;
			}
			if ((Object)(object)_editorCanvasObject == (Object)null || (Object)(object)_canvasRect == (Object)null)
			{
				LogCanvasCursorHidden("missing editor canvas " + context, force: true);
				return;
			}
			EnsureCanvasCursor();
			if ((Object)(object)_canvasCursorObject == (Object)null || (Object)(object)_canvasCursorRect == (Object)null || (Object)(object)_canvasCursorGraphic == (Object)null)
			{
				LogCanvasCursorHidden("cursor build failed " + context, force: true);
				return;
			}
			if (Cursor.visible || (int)Cursor.lockState != 0)
			{
				Cursor.visible = false;
				Cursor.lockState = (CursorLockMode)0;
			}
			CursorVisualMode mode = CursorVisualMode.Dot;
			float num = 15f;
			Color cursorColor = Color.white;
			string targetMode = "Navigation";
			int triangleIndex = -1;
			Vector2 uv = Vector2.zero;
			string fallbackReason = string.Empty;
			if (TryResolveBrushCursor(out var diameter, out var color, out targetMode, out triangleIndex, out uv, out fallbackReason))
			{
				mode = CursorVisualModeForBrushShape(_brushShape);
				num = ClampCursorDiameter(diameter);
				cursorColor = color;
			}
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(Mathf.Clamp(_cursor.x, 0f, (float)Screen.width), Mathf.Clamp(_cursor.y, 0f, (float)Screen.height));
			Vector2 val2 = default(Vector2);
			if (!RectTransformUtility.ScreenPointToLocalPointInRectangle(_canvasRect, val, (Camera)null, ref val2))
			{
				Rect rect = _canvasRect.rect;
				Canvas component = _editorCanvasObject.GetComponent<Canvas>();
				float num2 = Mathf.Max(0.001f, (component != null) ? component.scaleFactor : 1f);
				((Vector2)(ref val2))..ctor(val.x / num2 + ((Rect)(ref rect)).xMin, val.y / num2 + ((Rect)(ref rect)).yMin);
				fallbackReason = AppendFallbackReason(fallbackReason, "screen-to-canvas fallback");
			}
			float num3 = (IsBrushCursorMode(mode) ? Mathf.Clamp(num + 10f, 22f, 300f) : 17f);
			_canvasCursorObject.SetActive(true);
			_canvasCursorObject.transform.SetAsLastSibling();
			_canvasCursorRect.anchoredPosition = val2;
			_canvasCursorRect.sizeDelta = new Vector2(num3, num3);
			((Graphic)_canvasCursorGraphic).raycastTarget = false;
			_canvasCursorGraphic.SetVisual(mode, cursorColor, num);
			LogCanvasCursorUpdated(force, context, mode, targetMode, num, triangleIndex, uv, fallbackReason, val, val2, num3);
		}

		private static string AppendFallbackReason(string current, string addition)
		{
			if (string.IsNullOrWhiteSpace(addition))
			{
				return current ?? string.Empty;
			}
			if (!string.IsNullOrWhiteSpace(current))
			{
				return current + "; " + addition;
			}
			return addition;
		}

		private void UpdateNativeCursor(bool force, string context)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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_00d2: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			if (_isOpen)
			{
				CursorVisualMode cursorVisualMode = CursorVisualMode.Dot;
				float num = 15f;
				Color color = Color.white;
				string targetMode = "Navigation";
				int triangleIndex = -1;
				Vector2 uv = Vector2.zero;
				string fallbackReason = string.Empty;
				if (TryResolveBrushCursor(out var diameter, out var color2, out targetMode, out triangleIndex, out uv, out fallbackReason))
				{
					cursorVisualMode = CursorVisualMode.BrushRing;
					num = ClampCursorDiameter(diameter);
					color = color2;
				}
				int num2 = ((cursorVisualMode == CursorVisualMode.BrushRing) ? Mathf.RoundToInt(num) : Mathf.RoundToInt(15f));
				int num3 = ((cursorVisualMode == CursorVisualMode.BrushRing) ? Mathf.Clamp(NextPowerOfTwo(num2 + 12), 32, 512) : 32);
				Vector2 hotspot = default(Vector2);
				((Vector2)(ref hotspot))..ctor((float)num3 * 0.5f, (float)num3 * 0.5f);
				string text = $"mode={cursorVisualMode}|tool={_tool}|target={targetMode}|diameter={num2}|color={ColorToHex(color)}|size={num3}";
				if (force || !string.Equals(text, _nativeCursorKey, StringComparison.Ordinal) || (Object)(object)_nativeCursorTexture == (Object)null)
				{
					SetNativeCursorTexture(cursorVisualMode, num3, num2, color, hotspot, text, context, targetMode, triangleIndex, uv, fallbackReason);
				}
				if (!Cursor.visible || (int)Cursor.lockState != 0)
				{
					Cursor.visible = true;
					Cursor.lockState = (CursorLockMode)0;
				}
				WarpNativeCursorIfNeeded(context);
			}
		}

		private void SetNativeCursorTexture(CursorVisualMode mode, int textureSize, int diameter, Color color, Vector2 hotspot, string key, string context, string targetMode, int triangleIndex, Vector2 uv, string fallbackReason)
		{
			//IL_0030: 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_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_000f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)_nativeCursorTexture != (Object)null)
				{
					Cursor.SetCursor((Texture2D)null, Vector2.zero, (CursorMode)0);
					Object.Destroy((Object)(object)_nativeCursorTexture);
					_nativeCursorTexture = null;
				}
				_nativeCursorTexture = CreateNativeCursorTexture(mode, textureSize, diameter, color);
				Cursor.SetCursor(_nativeCursorTexture, hotspot, (CursorMode)1);
				_nativeCursorKey = key;
				LogNativeCursorUpdated(mode, targetMode, diameter, triangleIndex, uv, fallbackReason, textureSize, hotspot, context);
			}
			catch (Exception ex)
			{
				LogNativeCursorSetFailed(key, context, ex);
			}
		}

		private static Texture2D CreateNativeCursorTexture(CursorVisualMode mode, int size, int diameter, Color color)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			Texture2D val = new Texture2D(size, size, (TextureFormat)4, false)
			{
				name = ((mode == CursorVisualMode.BrushRing) ? "DrawableSuitsNativeBrushCursor" : "DrawableSuitsNativeDotCursor"),
				wrapMode = (TextureWrapMode)1,
				filterMode = (FilterMode)1
			};
			Color32[] array = (Color32[])(object)new Color32[size * size];
			float center = (float)(size - 1) * 0.5f;
			if (mode == CursorVisualMode.Dot)
			{
				WriteNativeDotCursorPixels(array, size, center);
			}
			else
			{
				WriteNativeBrushCursorPixels(array, size, center, diameter, color);
			}
			val.SetPixels32(array);
			val.Apply(false, false);
			return val;
		}

		private static void WriteNativeDotCursorPixels(Color32[] pixels, int size, float center)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			float num = 7.5f;
			float num2 = 4.25f;
			for (int i = 0; i < size; i++)
			{
				for (int j = 0; j < size; j++)
				{
					float num3 = Vector2.Distance(new Vector2((float)j, (float)i), new Vector2(center, center));
					float num4 = 1f - Mathf.SmoothStep(num - 1f, num + 1f, num3);
					float num5 = 1f - Mathf.SmoothStep(num2 - 1f, num2 + 1f, num3);
					Color32 val = CompositeCursorPixel(new Color(0f, 0f, 0f, num4 * 0.95f), new Color(1f, 1f, 1f, num5));
					pixels[i * size + j] = val;
				}
			}
		}

		private static void WriteNativeBrushCursorPixels(Color32[] pixels, int size, float center, int diameter, Color color)
		{
			//IL_004d: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			float radius = (float)diameter * 0.5f;
			float thickness = Mathf.Clamp((float)diameter * 0.14f, 4f, 10f);
			float thickness2 = Mathf.Clamp((float)diameter * 0.07f, 2f, 6f);
			for (int i = 0; i < size; i++)
			{
				for (int j = 0; j < size; j++)
				{
					float distance = Vector2.Distance(new Vector2((float)j, (float)i), new Vector2(center, center));
					float num = RingAlpha(distance, radius, thickness) * 0.95f;
					float num2 = RingAlpha(distance, radius, thickness2) * Mathf.Clamp01(color.a);
					Color32 val = CompositeCursorPixel(new Color(0f, 0f, 0f, num), new Color(color.r, color.g, color.b, num2));
					pixels[i * size + j] = val;
				}
			}
		}

		private static float RingAlpha(float distance, float radius, float thickness)
		{
			float num = thickness * 0.5f;
			float num2 = radius - num;
			float num3 = radius + num;
			float num4 = 1f - Mathf.SmoothStep(num3 - 1f, num3 + 1f, distance);
			float num5 = Mathf.SmoothStep(num2 - 1f, num2 + 1f, distance);
			return Mathf.Clamp01(num4 * num5);
		}

		private static Color32 CompositeCursorPixel(Color background, Color foreground)
		{
			//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_0011: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_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_0064: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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_00f4: 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)
			float num = foreground.a + background.a * (1f - foreground.a);
			if (num <= 0.001f)
			{
				return new Color32((byte)0, (byte)0, (byte)0, (byte)0);
			}
			float num2 = (foreground.r * foreground.a + background.r * background.a * (1f - foreground.a)) / num;
			float num3 = (foreground.g * foreground.a + background.g * background.a * (1f - foreground.a)) / num;
			float num4 = (foreground.b * foreground.a + background.b * background.a * (1f - foreground.a)) / num;
			return new Color32((byte)Mathf.RoundToInt(Mathf.Clamp01(num2) * 255f), (byte)Mathf.RoundToInt(Mathf.Clamp01(num3) * 255f), (byte)Mathf.RoundToInt(Mathf.Clamp01(num4) * 255f), (byte)Mathf.RoundToInt(Mathf.Clamp01(num) * 255f));
		}

		private static int NextPowerOfTwo(int value)
		{
			int num;
			for (num = 1; num < value; num <<= 1)
			{
			}
			return num;
		}

		private void WarpNativeCursorIfNeeded(string context)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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)
			if (!string.Equals(_pointerSource, "Gamepad", StringComparison.OrdinalIgnoreCase))
			{
				return;
			}
			Mouse current = Mouse.current;
			if (current == null)
			{
				return;
			}
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(Mathf.Clamp(_cursor.x, 0f, (float)Screen.width), Mathf.Clamp(_cursor.y, 0f, (float)Screen.height));
			try
			{
				current.WarpCursorPosition(val);
				_lastMousePosition = val;
				_mousePositionAvailable = true;
				_ignoreMouseInputUntilTime = Time.unscaledTime + 0.12f;
				LogNativeCursorWarped(val, context);
			}
			catch (Exception ex)
			{
				LogNativeCursorSetFailed($"warp|target={val}", context, ex);
			}
		}

		private void ResetNativeCursor(string context)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Cursor.SetCursor((Texture2D)null, Vector2.zero, (CursorMode)0);
				if (!string.IsNullOrEmpty(_nativeCursorKey) || (Object)(object)_nativeCursorTexture != (Object)null)
				{
					DrawableSuitsDiagnostics.Info("NativeCursorReset: context=" + context + "; previousKey=" + _nativeCursorKey + "; previousTexture=" + DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_nativeCursorTexture));
				}
			}
			catch (Exception ex)
			{
				LogNativeCursorSetFailed("reset", context, ex);
			}
			if ((Object)(object)_nativeCursorTexture != (Object)null)
			{
				Object.Destroy((Object)(object)_nativeCursorTexture);
				_nativeCursorTexture = null;
			}
			_nativeCursorKey = string.Empty;
		}

		private static Rect RectFromCenter(Vector2 center, float size)
		{
			//IL_0000: 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_001e: Unknown result type (might be due to invalid IL or missing references)
			return new Rect(center.x - size * 0.5f, center.y - size * 0.5f, size, size);
		}

		private void DestroyLegacyCursorCanvas(string context)
		{
			if (!((Object)(object)_cursorCanvasObject == (Object)null))
			{
				DrawableSuitsDiagnostics.Info("Legacy cursor canvas destroyed. context=" + context + "; canvas=" + DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_cursorCanvasObject));
				Object.Destroy((Object)(object)_cursorCanvasObject);
				_cursorCanvasObject = null;
				_cursorCanvasRect = null;
				_cursorMarker = null;
				_cursorBackRect = null;
				_cursorFrontRect = null;
				_cursorBackImage = null;
				_cursorImage = null;
			}
		}

		private void HideCanvasCursor(string context, bool forceLog)
		{
			bool num = (Object)(object)_canvasCursorObject != (Object)null && _canvasCursorObject.activeSelf;
			if ((Object)(object)_canvasCursorObject != (Object)null)
			{
				_canvasCursorObject.SetActive(false);
			}
			if (num || forceLog)
			{
				LogCanvasCursorHidden(context, forceLog);
			}
		}

		private void DestroyCanvasCursor(string context)
		{
			if (!((Object)(object)_canvasCursorObject == (Object)null))
			{
				DrawableSuitsDiagnostics.Info("CanvasCursorHidden: context=" + context + "; destroyed=True; object=" + DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_canvasCursorObject));
				Object.Destroy((Object)(object)_canvasCursorObject);
				_canvasCursorObject = null;
				_canvasCursorRect = null;
				_canvasCursorGraphic = null;
			}
		}

		private void UpdateCursorMarker()
		{
			DestroyLegacyCursorCanvas("ignored legacy cursor update request");
		}

		private void ApplyDynamicCursorVisual()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: 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_01b3: 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_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			CursorVisualMode cursorVisualMode = CursorVisualMode.Dot;
			float diameter = 7f;
			Color color = Color.white;
			string targetMode = "Navigation";
			int triangleIndex = -1;
			Vector2 uv = Vector2.zero;
			string fallbackReason = string.Empty;
			if (TryResolveBrushCursor(out var diameter2, out var color2, out targetMode, out triangleIndex, out uv, out fallbackReason))
			{
				cursorVisualMode = CursorVisualMode.BrushRing;
				diameter = diameter2;
				color = color2;
			}
			Sprite val = ((cursorVisualMode == CursorVisualMode.BrushRing) ? EnsureCursorRingSprite() : EnsureCursorDotSprite());
			Sprite val2 = val;
			if ((Object)(object)_cursorImage.sprite != (Object)(object)val)
			{
				_cursorImage.sprite = val;
			}
			if ((Object)(object)_cursorBackImage.sprite != (Object)(object)val2)
			{
				_cursorBackImage.sprite = val2;
			}
			((Graphic)_cursorBackImage).color = ((cursorVisualMode == CursorVisualMode.BrushRing) ? new Color(0f, 0f, 0f, 0.95f) : new Color(0f, 0f, 0f, 0.85f));
			((Graphic)_cursorImage).color = color;
			((Graphic)_cursorBackImage).raycastTarget = false;
			((Graphic)_cursorImage).raycastTarget = false;
			float num = ((cursorVisualMode == CursorVisualMode.BrushRing) ? ClampCursorDiameter(diameter) : 7f);
			if (cursorVisualMode == CursorVisualMode.BrushRing)
			{
				_cursorMarker.sizeDelta = new Vector2(num + 8f, num + 8f);
				_cursorBackRect.sizeDelta = new Vector2(num + 6f, num + 6f);
				_cursorFrontRect.sizeDelta = new Vector2(num, num);
			}
			else
			{
				_cursorMarker.sizeDelta = new Vector2(17f, 17f);
				_cursorBackRect.sizeDelta = new Vector2(15f, 15f);
				_cursorFrontRect.sizeDelta = new Vector2(9f, 9f);
			}
			LogDynamicCursorUpdated(cursorVisualMode, targetMode, num, triangleIndex, uv, fallbackReason);
		}

		private bool TryResolveBrushCursor(out float diameter, out Color color, out string targetMode, out int triangleIndex, out Vector2 uv, out string fallbackReason)
		{
			//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_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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			diameter = 7f;
			color = Color.white;
			targetMode = "Navigation";
			triangleIndex = -1;
			uv = Vector2.zero;
			fallbackReason = string.Empty;
			if (_tool != EditorTool.Paint && _tool != EditorTool.Erase)
			{
				targetMode = _tool.ToString();
				return false;
			}
			color = ((_tool == EditorTool.Erase) ? new Color(0.65f, 0.85f, 1f, 0.95f) : new Color(_brushColor.r, _brushColor.g, _brushColor.b, 0.95f));
			if (!_canPaint)
			{
				targetMode = "Invalid";
				fallbackReason = "canPaint false";
				return false;
			}
			if (IsEditorModalOpen())
			{
				targetMode = (IsSavedDesignsPanelOpen() ? "SavedDesignsPanel" : "DesignCodePanel");
				return false;
			}
			Texture2D val = ((_selectedSuitId >= 0) ? DrawableSuitsPlugin.Registry.GetEditableTexture(_selectedSuitId) : null);
			if ((Object)(object)val == (Object)null)
			{
				targetMode = "Invalid";
				fallbackReason = "no editable texture";
				return false;
			}
			if (IsWorldThirdPersonMode)
			{
				if (IsCursorOverPreviewViewport())
				{
					targetMode = "TexturePanel";
					if (!TryGetTexturePreviewUv(_cursor, out uv))
					{
						fallbackReason = "texture panel uv miss";
						return false;
					}
					diameter = ComputeUvFallbackBrushDiameter(val);
					return true;
				}
				targetMode = "WorldThirdPerson";
				if (IsCursorOverEditorPanel())
				{
					targetMode = "EditorPanel";
					return false;
				}
				if (!TryGetWorldPaintHit(out var hit))
				{
					fallbackReason = "world miss";
					return false;
				}
				uv = ((RaycastHit)(ref hit)).textureCoord;
				triangleIndex = ((RaycastHit)(ref hit)).triangleIndex;
				if (!TryComputeWorldBrushCursorDiameter(hit, val, out diameter, out fallbackReason))
				{
					diameter = EstimateWorldBrushCursorDiameter(hit, val);
				}
				return true;
			}
			targetMode = "TextureFallback";
			if (!IsCursorOverPreviewViewport() || !TryGetTexturePreviewUv(_cursor, out uv))
			{
				fallbackReason = "uv miss";
				return false;
			}
			diameter = ComputeUvFallbackBrushDiameter(val);
			return true;
		}

		private float ComputeUvFallbackBrushDiameter(Texture2D texture)
		{
			//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_0029: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)texture == (Object)null || (Object)(object)_previewViewportRect == (Object)null)
			{
				return 18f;
			}
			Vector2 rectTransformScreenSize = GetRectTransformScreenSize(_previewViewportRect);
			if (rectTransformScreenSize.x <= 0f || rectTransformScreenSize.y <= 0f)
			{
				return 18f;
			}
			Rect uvPanelViewRect = GetUvPanelViewRect();
			float num = rectTransformScreenSize.x / Mathf.Max(1f, (float)((Texture)texture).width * ((Rect)(ref uvPanelViewRect)).width);
			float num2 = rectTransformScreenSize.y / Mathf.Max(1f, (float)((Texture)texture).height * ((Rect)(ref uvPanelViewRect)).height);
			return ScreenPixelsToCanvasUnits(EffectiveBrushRadiusPixels() * 2f * Mathf.Max(num, num2));
		}

		private static Vector2 GetRectTransformScreenSize(RectTransform rectTransform)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_003f: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rectTransform == (Object)null)
			{
				return Vector2.zero;
			}
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			rectTransform.GetWorldCorners(array);
			Vector2 val = RectTransformUtility.WorldToScreenPoint((Camera)null, array[0]);
			Vector2 val2 = RectTransformUtility.WorldToScreenPoint((Camera)null, array[2]);
			return new Vector2(Mathf.Abs(val2.x - val.x), Mathf.Abs(val2.y - val.y));
		}

		private bool TryComputeWorldBrushCursorDiameter(RaycastHit hit, Texture2D texture, out float diameter, out string fallbackReason)
		{
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			diameter = 0f;
			fallbackReason = string.Empty;
			if ((Object)(object)_worldEditorCamera == (Object)null || (Object)(object)_worldPaintProxyObject == (Object)null || (Object)(object)_worldPaintMesh == (Object)null || (Object)(object)texture == (Object)null)
			{
				fallbackReason = "world cursor dependencies missing";
				return false;
			}
			if (((RaycastHit)(ref hit)).triangleIndex < 0)
			{
				fallbackReason = $"invalid triangle {((RaycastHit)(ref hit)).triangleIndex}";
				return false;
			}
			int[] triangles = _worldPaintMesh.triangles;
			Vector3[] vertices = _worldPaintMesh.vertices;
			Vector2[] uv = _worldPaintMesh.uv;
			int num = ((RaycastHit)(ref hit)).triangleIndex * 3;
			if (triangles == null || vertices == null || uv == null || num < 0 || num + 2 >= triangles.Length)
			{
				fallbackReason = $"triangle array unavailable index={((RaycastHit)(ref hit)).triangleIndex}";
				return false;
			}
			int num2 = triangles[num];
			int num3 = triangles[num + 1];
			int num4 = triangles[num + 2];
			if (num2 < 0 || num3 < 0 || num4 < 0 || num2 >= vertices.Length || num3 >= vertices.Length || num4 >= vertices.Length || num2 >= uv.Length || num3 >= uv.Length || num4 >= uv.Length)
			{
				fallbackReason = $"triangle vertex out of range index={((RaycastHit)(ref hit)).triangleIndex}";
				return false;
			}
			Vector3 val = vertices[num2];
			Vector3 val2 = vertices[num3];
			Vector3 val3 = vertices[num4];
			Vector2 val4 = uv[num2];
			Vector2 val5 = uv[num3];
			Vector2 val6 = uv[num4];
			Vector3 val7 = val2 - val;
			Vector3 val8 = val3 - val;
			Vector2 val9 = val5 - val4;
			Vector2 val10 = val6 - val4;
			float num5 = val9.x * val10.y - val9.y * val10.x;
			if (Mathf.Abs(num5) < 1E-06f)
			{
				fallbackReason = $"degenerate uv triangle {((RaycastHit)(ref hit)).triangleIndex}";
				return false;
			}
			float num6 = 1f / num5;
			Vector3 val11 = (val7 * val10.y - val8 * val9.y) * num6;
			Vector3 val12 = (val8 * val9.x - val7 * val10.x) * num6;
			Vector3 val13 = _worldPaintProxyObject.transform.InverseTransformPoint(((RaycastHit)(ref hit)).point);
			float num7 = EffectiveBrushRadiusPixels();
			float num8 = num7 / Mathf.Max(1f, (float)((Texture)texture).width);
			float num9 = num7 / Mathf.Max(1f, (float)((Texture)texture).height);
			Transform transform = _worldPaintProxyObject.transform;
			Vector2? val14 = ProjectToScreen(transform.TransformPoint(val13 + val11 * num8));
			Vector2? val15 = ProjectToScreen(transform.TransformPoint(val13 - val11 * num8));
			Vector2? val16 = ProjectToScreen(transform.TransformPoint(val13 + val12 * num9));
			Vector2? val17 = ProjectToScreen(transform.TransformPoint(val13 - val12 * num9));
			if (!val14.HasValue || !val15.HasValue || !val16.HasValue || !val17.HasValue)
			{
				fallbackReason = $"projection failed triangle={((RaycastHit)(ref hit)).triangleIndex}";
				return false;
			}
			float num10 = Vector2.Distance(val14.Value, val15.Value);
			float num11 = Vector2.Distance(val16.Value, val17.Value);
			float num12 = Mathf.Max(num10, num11);
			if (float.IsNaN(num12) || float.IsInfinity(num12) || num12 <= 0.5f)
			{
				fallbackReason = $"invalid projected diameter {num12:0.###}";
				return false;
			}
			diameter = ScreenPixelsToCanvasUnits(num12);
			return true;
		}

		private Vector2? ProjectToScreen(Vector3 worldPoint)
		{
			//IL_001e: 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_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_0058: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_worldEditorCamera == (Object)null)
			{
				return null;
			}
			Vector3 val = _worldEditorCamera.WorldToScreenPoint(worldPoint);
			if (val.z <= Mathf.Max(0.001f, _worldEditorCamera.nearClipPlane))
			{
				return null;
			}
			return new Vector2(val.x, val.y);
		}

		private float EstimateWorldBrushCursorDiameter(RaycastHit hit, Texture2D texture)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if ((Object)(object)_worldEditorCamera == (Object)null || (Object)(object)texture == (Object)null)
			{
				return ClampCursorDiameter(_brushSize * 1.25f);
			}
			float num;
			if (!((Object)(object)_worldPaintMesh != (Object)null))
			{
				num = 1.8f;
			}
			else
			{
				Bounds bounds = _worldPaintMesh.bounds;
				float x = ((Bounds)(ref bounds)).size.x;
				bounds = _worldPaintMesh.bounds;
				float y = ((Bounds)(ref bounds)).size.y;
				bounds = _worldPaintMesh.bounds;
				num = Mathf.Max(0.05f, Mathf.Max(x, Mathf.Max(y, ((Bounds)(ref bounds)).size.z)));
			}
			float num2 = num;
			float num3 = _brushSize * 2f * num2 / (float)Mathf.Max(1, Mathf.Max(((Texture)texture).width, ((Texture)texture).height));
			Vector3 right = ((Component)_worldEditorCamera).transform.right;
			Vector2? val = ProjectToScreen(((RaycastHit)(ref hit)).point);
			Vector2? val2 = ProjectToScreen(((RaycastHit)(ref hit)).point + right * (num3 * 0.5f));
			if (!val.HasValue || !val2.HasValue)
			{
				return ClampCursorDiameter(_brushSize * 1.25f);
			}
			return ScreenPixelsToCanvasUnits(Vector2.Distance(val.Value, val2.Value) * 2f);
		}

		private float ScreenPixelsToCanvasUnits(float screenPixels)
		{
			Canvas val = (((Object)(object)_editorCanvasObject != (Object)null) ? _editorCanvasObject.GetComponent<Canvas>() : null);
			float num = Mathf.Max(0.001f, ((Object)(object)val != (Object)null) ? val.scaleFactor : 1f);
			return screenPixels / num;
		}

		private static float ClampCursorDiameter(float diameter)
		{
			return Mathf.Clamp(diameter, 18f, 280f);
		}

		private static CursorVisualMode CursorVisualModeForBrushShape(BrushShape shape)
		{
			return shape switch
			{
				BrushShape.Square => CursorVisualMode.BrushSquare, 
				BrushShape.Pixel => CursorVisualMode.BrushPixel, 
				_ => CursorVisualMode.BrushRing, 
			};
		}

		private static bool IsBrushCursorMode(CursorVisualMode mode)
		{
			if (mode != CursorVisualMode.BrushRing && mode != CursorVisualMode.BrushSquare)
			{
				return mode == CursorVisualMode.BrushPixel;
			}
			return true;
		}

		private bool IsDesignCodePanelOpen()
		{
			if ((Object)(object)_designCodePanelObject != (Object)null)
			{
				return _designCodePanelObject.activeInHierarchy;
			}
			return false;
		}

		private bool IsSavedDesignsPanelOpen()
		{
			if ((Object)(object)_savedDesignsPanelObject != (Object)null)
			{
				return _savedDesignsPanelObject.activeInHierarchy;
			}
			return false;
		}

		private bool IsDecalsPanelOpen()
		{
			if ((Object)(object)_decalsPanelObject != (Object)null)
			{
				return _decalsPanelObject.activeInHierarchy;
			}
			return false;
		}

		private bool IsStickersPanelOpen()
		{
			if ((Object)(object)_stickersPanelObject != (Object)null)
			{
				return _stickersPanelObject.activeInHierarchy;
			}
			return false;
		}

		private bool IsPlacementEditPanelOpen()
		{
			if ((Object)(object)_placementEditPanelObject != (Object)null)
			{
				return _placementEditPanelObject.activeInHierarchy;
			}
			return false;
		}

		private bool IsEditorModalOpen()
		{
			if (!IsDesignCodePanelOpen() && !IsSavedDesignsPanelOpen() && !IsDecalsPanelOpen() && !IsStickersPanelOpen())
			{
				return IsPlacementEditPanelOpen();
			}
			return true;
		}

		private string DescribeOpenEditorModal()
		{
			if (IsPlacementEditPanelOpen())
			{
				return "PlacementEdit";
			}
			if (IsDecalsPanelOpen())
			{
				return "Decals";
			}
			if (IsStickersPanelOpen())
			{
				return "Stickers";
			}
			if (IsSavedDesignsPanelOpen())
			{
				return "SavedDesigns";
			}
			if (IsDesignCodePanelOpen())
			{
				return "DesignCode";
			}
			return "None";
		}

		private Texture2D EnsureCursorDotTexture()
		{
			if ((Object)(object)_cursorDotTexture == (Object)null)
			{
				_cursorDotTexture = CreateCursorTexture("DrawableSuitsImmediateCursorDot", 32, filled: true);
			}
			return _cursorDotTexture;
		}

		private Texture2D EnsureCursorRingTexture()
		{
			if ((Object)(object)_cursorRingTexture == (Object)null)
			{
				_cursorRingTexture = CreateCursorTexture("DrawableSuitsImmediateCursorRing", 128, filled: false);
			}
			return _cursorRingTexture;
		}

		private Sprite EnsureCursorDotSprite()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_cursorDotSprite != (Object)null)
			{
				return _cursorDotSprite;
			}
			_cursorDotTexture = EnsureCursorDotTexture();
			_cursorDotSprite = Sprite.Create(_cursorDotTexture, new Rect(0f, 0f, (float)((Texture)_cursorDotTexture).width, (float)((Texture)_cursorDotTexture).height), new Vector2(0.5f, 0.5f), 100f);
			((Object)_cursorDotSprite).name = "DrawableSuitsCursorDotSprite";
			return _cursorDotSprite;
		}

		private Sprite EnsureCursorRingSprite()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_cursorRingSprite != (Object)null)
			{
				return _cursorRingSprite;
			}
			_cursorRingTexture = EnsureCursorRingTexture();
			_cursorRingSprite = Sprite.Create(_cursorRingTexture, new Rect(0f, 0f, (float)((Texture)_cursorRingTexture).width, (float)((Texture)_cursorRingTexture).height), new Vector2(0.5f, 0.5f), 100f);
			((Object)_cursorRingSprite).name = "DrawableSuitsCursorRingSprite";
			return _cursorRingSprite;
		}

		private static Texture2D CreateCursorTexture(string name, int size, bool filled)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(size, size, (TextureFormat)4, false)
			{
				name = name,
				wrapMode = (TextureWrapMode)1,
				filterMode = (FilterMode)1
			};
			Color32[] array = (Color32[])(object)new Color32[size * size];
			float num = (float)(size - 1) * 0.5f;
			float num2 = (float)size * 0.46f;
			float num3 = (filled ? 0f : ((float)size * 0.36f));
			float num4 = Mathf.Max(1f, (float)size * 0.035f);
			for (int i = 0; i < size; i++)
			{
				for (int j = 0; j < size; j++)
				{
					float num5 = (float)j - num;
					float num6 = (float)i - num;
					float num7 = Mathf.Sqrt(num5 * num5 + num6 * num6);
					float num8;
					if (filled)
					{
						num8 = 1f - Mathf.SmoothStep(num2 - num4, num2 + num4, num7);
					}
					else
					{
						float num9 = 1f - Mathf.SmoothStep(num2 - num4, num2 + num4, num7);
						float num10 = Mathf.SmoothStep(num3 - num4, num3 + num4, num7);
						num8 = num9 * num10;
					}
					array[i * size + j] = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, (byte)Mathf.RoundToInt(Mathf.Clamp01(num8) * 255f));
				}
			}
			val.SetPixels32(array);
			val.Apply(false, false);
			return val;
		}

		private void DestroyCursorGraphics()
		{
			ResetNativeCursor("destroy cursor graphics");
			DestroyCanvasCursor("destroy cursor graphics");
			if ((Object)(object)_cursorDotSprite != (Object)null)
			{
				Object.Destroy((Object)(object)_cursorDotSprite);
				_cursorDotSprite = null;
			}
			if ((Object)(object)_cursorRingSprite != (Object)null)
			{
				Object.Destroy((Object)(object)_cursorRingSprite);
				_cursorRingSprite = null;
			}
			if ((Object)(object)_cursorDotTexture != (Object)null)
			{
				Object.Destroy((Object)(object)_cursorDotTexture);
				_cursorDotTexture = null;
			}
			if ((Object)(object)_cursorRingTexture != (Object)null)
			{
				Object.Destroy((Object)(object)_cursorRingTexture);
				_cursorRingTexture = null;
			}
		}

		private void LogCanvasCursorBuilt(string context)
		{
			//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)
			string[] obj = new string[14]
			{
				"CanvasCursorBuilt: context=",
				context,
				"; object=",
				DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_canvasCursorObject),
				"; active=",
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null
			};
			GameObject canvasCursorObject = _canvasCursorObject;
			obj[5] = ((canvasCursorObject != null) ? canvasCursorObject.activeSelf.ToString() : null) ?? "null";
			obj[6] = "; root=";
			obj[7] = DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_editorCanvasObject);
			obj[8] = "; rootChildren=";
			GameObject editorCanvasObject = _editorCanvasObject;
			obj[9] = ((editorCanvasObject != null) ? editorCanvasObject.transform.childCount.ToString() : null) ?? "null";
			obj[10] = "; raycastTarget=";
			DrawableCanvasCursorGraphic canvasCursorGraphic = _canvasCursorGraphic;
			obj[11] = ((canvasCursorGraphic != null) ? ((Graphic)canvasCursorGraphic).raycastTarget.ToString() : null) ?? "null";
			obj[12] = "; rootRect=";
			obj[13] = (((Object)(object)_canvasRect != (Object)null) ? ((object)_canvasRect.rect/*cast due to .constrained prefix*/).ToString() : "null");
			DrawableSuitsDiagnostics.Info(string.Concat(obj));
		}

		private unsafe void LogCanvasCursorUpdated(bool force, string context, CursorVisualMode mode, string targetMode, float diameter, int triangleIndex, Vector2 uv, string fallbackReason, Vector2 screenPosition, Vector2 localPosition, float rootSize)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: 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_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			int num = (((Object)(object)_canvasCursorObject != (Object)null) ? _canvasCursorObject.transform.GetSiblingIndex() : (-1));
			string text = $"mode={mode}|tool={_tool}|shape={_brushShape}|source={_pointerSource}|target={targetMode}|brush={Mathf.RoundToInt(EffectiveBrushRadiusPixels())}|diameter={diameter:0.#}|tri={triangleIndex}|uv={uv.x:0.###},{uv.y:0.###}|fallback={fallbackReason}|screen={screenPosition.x:0.#},{screenPosition.y:0.#}|local={localPosition.x:0.#},{localPosition.y:0.#}|size={rootSize:0.#}|context={context}";
			if (force || !(Time.unscaledTime - _lastCanvasCursorLogTime < 0.75f) || !string.Equals(text, _lastCanvasCursorLogKey, StringComparison.Ordinal))
			{
				_lastCanvasCursorLogTime = Time.unscaledTime;
				_lastCanvasCursorLogKey = text;
				object[] obj = new object[16]
				{
					text, null, null, null, null, null, null, null, null, null,
					null, null, null, null, null, null
				};
				GameObject canvasCursorObject = _canvasCursorObject;
				obj[1] = ((canvasCursorObject != null) ? canvasCursorObject.activeSelf.ToString() : null) ?? "null";
				GameObject canvasCursorObject2 = _canvasCursorObject;
				obj[2] = ((canvasCursorObject2 != null) ? canvasCursorObject2.activeInHierarchy.ToString() : null) ?? "null";
				obj[3] = num;
				GameObject editorCanvasObject = _editorCanvasObject;
				obj[4] = ((editorCanvasObject != null) ? editorCanvasObject.transform.childCount.ToString() : null) ?? "null";
				object obj2;
				Rect rect;
				if (!((Object)(object)_canvasCursorRect != (Object)null))
				{
					obj2 = "null";
				}
				else
				{
					rect = _canvasCursorRect.rect;
					obj2 = ((object)((Rect)(ref rect)).size/*cast due to .constrained prefix*/).ToString();
				}
				obj[5] = obj2;
				obj[6] = (((Object)(object)_canvasCursorRect != (Object)null) ? ((object)_canvasCursorRect.anchoredPosition/*cast due to .constrained prefix*/).ToString() : "null");
				DrawableCanvasCursorGraphic canvasCursorGraphic = _canvasCursorGraphic;
				obj[7] = ((canvasCursorGraphic != null) ? ((Graphic)canvasCursorGraphic).raycastTarget.ToString() : null) ?? "null";
				obj[8] = _canvasCursorGraphic?.Mode.ToString() ?? "null";
				obj[9] = _canvasCursorGraphic?.Diameter.ToString("0.#") ?? "null";
				GameObject editorCanvasObject2 = _editorCanvasObject;
				object obj3;
				if (editorCanvasObject2 == null)
				{
					obj3 = null;
				}
				else
				{
					Canvas component = editorCanvasObject2.GetComponent<Canvas>();
					obj3 = ((component != null) ? component.scaleFactor.ToString("0.###") : null);
				}
				if (obj3 == null)
				{
					obj3 = "null";
				}
				obj[10] = obj3;
				object obj4;
				if (!((Object)(object)_canvasRect != (Object)null))
				{
					obj4 = "null";
				}
				else
				{
					rect = _canvasRect.rect;
					obj4 = ((object)(*(Rect*)(&rect))/*cast due to .constrained prefix*/).ToString();
				}
				obj[11] = obj4;
				obj[12] = Cursor.visible;
				obj[13] = Cursor.lockState;
				obj[14] = IsCursorOverEditorPanel();
				obj[15] = _previewMode;
				DrawableSuitsDiagnostics.Info(string.Format("CanvasCursorUpdated: {0}; active={1}; activeInHierarchy={2}; sibling={3}; rootChildCount={4}; rectSize={5}; anchored={6}; raycastTarget={7}; graphicMode={8}; graphicDiameter={9}; canvasScale={10}; rootRect={11}; nativeCursorVisible={12}; nativeCursorLock={13}; overPanel={14}; previewMode={15}", obj));
			}
		}

		private void LogCanvasCursorHidden(string context, bool force)
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			string text = context ?? "unknown";
			if (force || !(Time.unscaledTime - _lastCanvasCursorHiddenTime < 1.5f) || !string.Equals(text, _lastCanvasCursorHiddenKey, StringComparison.Ordinal))
			{
				_lastCanvasCursorHiddenTime = Time.unscaledTime;
				_lastCanvasCursorHiddenKey = text;
				object[] obj = new object[7]
				{
					text,
					DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_canvasCursorObject),
					null,
					null,
					null,
					null,
					null
				};
				GameObject canvasCursorObject = _canvasCursorObject;
				obj[2] = ((canvasCursorObject != null) ? canvasCursorObject.activeSelf.ToString() : null) ?? "null";
				obj[3] = _isOpen;
				obj[4] = CanvasActiveForDiagnostics;
				obj[5] = Cursor.visible;
				obj[6] = Cursor.lockState;
				DrawableSuitsDiagnostics.Info(string.Format("CanvasCursorHidden: context={0}; object={1}; active={2}; isOpen={3}; canvasActive={4}; nativeCursorVisible={5}; nativeCursorLock={6}", obj));
			}
		}

		private void LogDynamicCursorUpdated(CursorVisualMode mode, string targetMode, float diameter, int triangleIndex, Vector2 uv, string fallbackReason)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: 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_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			string text = $"mode={mode}|tool={_tool}|source={_pointerSource}|target={targetMode}|brush={Mathf.RoundToInt(_brushSize)}|diameter={diameter:0.#}|tri={triangleIndex}|uv={uv.x:0.###},{uv.y:0.###}|fallback={fallbackReason}";
			if (!(Time.unscaledTime - _lastDynamicCursorLogTime < 0.75f) || !string.Equals(text, _lastDynamicCursorLogKey, StringComparison.Ordinal))
			{
				_lastDynamicCursorLogTime = Time.unscaledTime;
				_lastDynamicCursorLogKey = text;
				object[] obj = new object[14]
				{
					text,
					_canPaint,
					IsCursorOverEditorPanel(),
					IsCursorOverPreviewViewport(),
					_cursor,
					((Object)(object)_cursorMarker != (Object)null) ? ((object)_cursorMarker.anchoredPosition/*cast due to .constrained prefix*/).ToString() : "null",
					((Object)(object)_cursorMarker != (Object)null) ? ((object)_cursorMarker.sizeDelta/*cast due to .constrained prefix*/).ToString() : "null",
					((Object)(object)_cursorFrontRect != (Object)null) ? ((object)_cursorFrontRect.sizeDelta/*cast due to .constrained prefix*/).ToString() : "null",
					((Object)(object)_cursorBackRect != (Object)null) ? ((object)_cursorBackRect.sizeDelta/*cast due to .constrained prefix*/).ToString() : "null",
					null,
					null,
					null,
					null,
					null
				};
				Image cursorImage = _cursorImage;
				object obj2;
				if (cursorImage == null)
				{
					obj2 = null;
				}
				else
				{
					Sprite sprite = cursorImage.sprite;
					obj2 = ((sprite != null) ? ((Object)sprite).name : null);
				}
				if (obj2 == null)
				{
					obj2 = "null";
				}
				obj[9] = obj2;
				Image cursorBackImage = _cursorBackImage;
				object obj3;
				if (cursorBackImage == null)
				{
					obj3 = null;
				}
				else
				{
					Sprite sprite2 = cursorBackImage.sprite;
					obj3 = ((sprite2 != null) ? ((Object)sprite2).name : null);
				}
				if (obj3 == null)
				{
					obj3 = "null";
				}
				obj[10] = obj3;
				obj[11] = 32760;
				obj[12] = DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_canvasCursorObject);
				obj[13] = _previewMode;
				DrawableSuitsDiagnostics.Info(string.Format("DynamicCursorUpdated: {0}; canPaint={1}; overPanel={2}; overPreview={3}; screenCursor={4}; anchored={5}; rootSize={6}; frontSize={7}; backSize={8}; frontSprite={9}; backSprite={10}; editorCanvasOrder={11}; canvasCursor={12}; previewMode={13}", obj));
			}
		}

		private void LogImmediateCursorUpdated(CursorVisualMode mode, string targetMode, float diameter, int triangleIndex, Vector2 uv, string fallbackReason, Rect drawRect, Texture2D texture)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			string text = $"mode={mode}|tool={_tool}|source={_pointerSource}|target={targetMode}|brush={Mathf.RoundToInt(_brushSize)}|diameter={diameter:0.#}|tri={triangleIndex}|uv={uv.x:0.###},{uv.y:0.###}|fallback={fallbackReason}";
			if (!(Time.unscaledTime - _lastDynamicCursorLogTime < 0.75f) || !string.Equals(text, _lastDynamicCursorLogKey, StringComparison.Ordinal))
			{
				_lastDynamicCursorLogTime = Time.unscaledTime;
				_lastDynamicCursorLogKey = text;
				DrawableSuitsDiagnostics.Info(string.Format("ImmediateCursorUpdated: {0}; canPaint={1}; overPanel={2}; overPreview={3}; screenCursor={4}; imguiRect={5}; texture={6}:{7}x{8}; guiDepth={9}; systemCursorVisible={10}; cursorLock={11}; previewMode={12}", text, _canPaint, IsCursorOverEditorPanel(), IsCursorOverPreviewViewport(), _cursor, drawRect, ((texture != null) ? ((Object)texture).name : null) ?? "null", ((texture != null) ? ((Texture)texture).width.ToString() : null) ?? "null", ((texture != null) ? ((Texture)texture).height.ToString() : null) ?? "null", int.MinValue, Cursor.visible, Cursor.lockState, _previewMode));
			}
		}

		private void LogImmediateCursorDrawSkipped(string reason)
		{
			//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_008b: Unknown result type (might be due to invalid IL or missing references)
			string text = reason ?? "unknown";
			if (!(Time.unscaledTime - _lastImmediateCursorSkipLogTime < 1.5f) || !string.Equals(text, _lastImmediateCursorSkipLog, StringComparison.Ordinal))
			{
				_lastImmediateCursorSkipLogTime = Time.unscaledTime;
				_lastImmediateCursorSkipLog = text;
				object[] obj = new object[8] { text, _isOpen, null, null, null, null, null, null };
				Event current = Event.current;
				obj[2] = ((current != null) ? ((object)current.type/*cast due to .constrained prefix*/).ToString() : null) ?? "null";
				obj[3] = _cursor;
				obj[4] = Screen.width;
				obj[5] = Screen.height;
				obj[6] = _tool;
				obj[7] = _pointerSource;
				DrawableSuitsDiagnostics.Warn(string.Format("ImmediateCursorDrawSkipped: reason={0}; isOpen={1}; eventType={2}; cursor={3}; screen={4}x{5}; tool={6}; pointerSource={7}", obj));
			}
		}

		private void LogNativeCursorUpdated(CursorVisualMode mode, string targetMode, int diameter, int triangleIndex, Vector2 uv, string fallbackReason, int textureSize, Vector2 hotspot, string context)
		{
			//IL_0068: 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_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			string text = string.Format("mode={0}|tool={1}|source={2}|target={3}|diameter={4}|color={5}|tri={6}|uv={7:0.###},{8:0.###}|fallback={9}|context={10}", mode, _tool, _pointerSource, targetMode, diameter, ((Object)(object)_nativeCursorTexture != (Object)null) ? ((Object)_nativeCursorTexture).name : "null", triangleIndex, uv.x, uv.y, fallbackReason, context);
			if (!(Time.unscaledTime - _lastNativeCursorLogTime < 0.5f) || !string.Equals(text, _lastNativeCursorLogKey, StringComparison.Ordinal))
			{
				_lastNativeCursorLogTime = Time.unscaledTime;
				_lastNativeCursorLogKey = text;
				DrawableSuitsDiagnostics.Info($"NativeCursorUpdated: {text}; screenCursor={_cursor}; texture={DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_nativeCursorTexture)}; textureSize={textureSize}; hotspot={hotspot}; cursorVisible={Cursor.visible}; cursorLock={Cursor.lockState}; canPaint={_canPaint}; overPanel={IsCursorOverEditorPanel()}; overPreview={IsCursorOverPreviewViewport()}; warpGuardUntil={_ignoreMouseInputUntilTime:0.###}; previewMode={_previewMode}");
			}
		}

		private void LogNativeCursorWarped(Vector2 target, string context)
		{
			//IL_0011: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			string text = $"{context}|{target.x:0.#},{target.y:0.#}|source={_pointerSource}";
			if (!(Time.unscaledTime - _lastNativeCursorWarpTime < 0.25f) || !string.Equals(text, _lastNativeCursorWarpKey, StringComparison.Ordinal))
			{
				_lastNativeCursorWarpTime = Time.unscaledTime;
				_lastNativeCursorWarpKey = text;
				DrawableSuitsDiagnostics.Info($"NativeCursorWarped: context={context}; target={target}; pointerSource={_pointerSource}; ignoreMouseUntil={_ignoreMouseInputUntilTime:0.###}; mouseAvailable={_mousePositionAvailable}; lastMouse={_lastMousePosition}");
			}
		}

		private void LogNativeCursorSetFailed(string key, string context, Exception ex)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			string text = context + "|" + key + "|" + ex.GetType().Name + ":" + ex.Message;
			if (!(Time.unscaledTime - _lastNativeCursorFailureTime < 1.5f) || !string.Equals(text, _lastNativeCursorFailureKey, StringComparison.Ordinal))
			{
				_lastNativeCursorFailureTime = Time.unscaledTime;
				_lastNativeCursorFailureKey = text;
				DrawableSuitsDiagnostics.Exception($"NativeCursorSetFailed: context={context}; key={key}; cursor={_cursor}; visible={Cursor.visible}; lock={Cursor.lockState}", ex);
			}
		}

		private void LogCursorCanvasState(string context)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: 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_0186: Unknown result type (might be due to invalid IL or missing references)
			Canvas val = (((Object)(object)_cursorCanvasObject != (Object)null) ? _cursorCanvasObject.GetComponent<Canvas>() : null);
			object[] obj = new object[17]
			{
				context,
				DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_cursorCanvasObject),
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null
			};
			GameObject cursorCanvasObject = _cursorCanvasObject;
			obj[2] = ((cursorCanvasObject != null) ? cursorCanvasObject.activeSelf.ToString() : null) ?? "null";
			obj[3] = ((val != null) ? ((object)val.renderMode/*cast due to .constrained prefix*/).ToString() : null) ?? "null";
			obj[4] = ((val != null) ? val.sortingOrder.ToString() : null) ?? "null";
			obj[5] = 32760;
			obj[6] = ((val != null) ? val.overrideSorting.ToString() : null) ?? "null";
			obj[7] = (Object)(object)_cursorCanvasObject != (Object)null && (Object)(object)_cursorCanvasObject.GetComponent<GraphicRaycaster>() != (Object)null;
			obj[8] = Screen.width;
			obj[9] = Screen.height;
			obj[10] = _cursor;
			obj[11] = DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_cursorMarker);
			RectTransform cursorMarker = _cursorMarker;
			obj[12] = ((cursorMarker != null) ? ((Component)cursorMarker).gameObject.activeSelf.ToString() : null) ?? "null";
			obj[13] = (((Object)(object)_cursorMarker != (Object)null) ? ((object)_cursorMarker.anchoredPosition/*cast due to .constrained prefix*/).ToString() : "null");
			obj[14] = DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_cursorImage);
			obj[15] = DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_cursorBackImage);
			obj[16] = DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_canvasCursorObject);
			DrawableSuitsDiagnostics.Info(string.Format("CursorCanvasState[{0}]: legacyCanvasObject={1}; active={2}; renderMode={3}; sortingOrder={4}; editorCanvasOrder={5}; overrideSorting={6}; hasRaycaster={7}; screen={8}x{9}; cursor={10}; marker={11}; markerActive={12}; markerPos={13}; frontImage={14}; backImage={15}; canvasCursor={16}", obj));
		}

		private void UpdateBrushIndicator()
		{
			if (!((Object)(object)_brushIndicator == (Object)null))
			{
				((Component)_brushIndicator).gameObject.SetActive(false);
			}
		}

		private void UpdateDecalPlacementPreview()
		{
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: 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)
			if (!_isOpen || !IsPlacementTool(_tool) || !_canPaint || _suppressDecalPreviewUntilRelease)
			{
				HideDecalPlacementPreview("not eligible", forceLog: false);
				return;
			}
			if (IsEditorModalOpen())
			{
				HideDecalPlacementPreview("editor modal open", forceLog: false);
				LogPlacementPreviewSkippedForModal();
				return;
			}
			Texture2D editableTexture = DrawableSuitsPlugin.Registry.GetEditableTexture(_selectedSuitId);
			Vector2 uv2;
			if ((Object)(object)editableTexture == (Object)null)
			{
				HideDecalPlacementPreview("no editable texture", forceLog: false);
			}
			else if (IsWorldThirdPersonMode && IsCursorOverPreviewViewport())
			{
				if (!TryGetTexturePreviewUv(_cursor, out var uv))
				{
					HideDecalPlacementPreview("texture panel miss", forceLog: false);
					return;
				}
				MirrorPaintTarget mirrorTarget = ResolveUvMirrorTarget(editableTexture, uv, allowStatus: false, "TexturePanel");
				if (!TryGetActivePlacementStamp(out var stampTexture, out var failureReason))
				{
					HandlePlacementStampFailure(failureReason);
				}
				else
				{
					ShowUvPlacementPreview(editableTexture, uv, mirrorTarget, stampTexture, "TexturePanel");
				}
			}
			else if (IsWorldThirdPersonMode)
			{
				if (IsCursorOverEditorPanel() || !TryGetWorldPaintHit(out var hit))
				{
					HideDecalPlacementPreview("world miss", forceLog: false);
					return;
				}
				MirrorPaintTarget mirrorTarget2 = ResolveWorldMirrorTarget(editableTexture, hit, allowStatus: false);
				if (_tool == EditorTool.Text)
				{
					if (!TryGetActivePlacementStamp(out var stampTexture2, out var failureReason2))
					{
						HandlePlacementStampFailure(failureReason2);
					}
					else
					{
						ShowWorldTextPlacementPreview(editableTexture, hit, mirrorTarget2, stampTexture2);
					}
				}
				else if (!ShouldDelayWorldPlacementPreviewUntilIdle(editableTexture, hit, mirrorTarget2))
				{
					if (!TryGetActivePlacementStamp(out var stampTexture3, out var failureReason3))
					{
						HandlePlacementStampFailure(failureReason3);
					}
					else
					{
						ShowWorldPlacementPreview(editableTexture, hit, mirrorTarget2, stampTexture3);
					}
				}
			}
			else if (!TryGetTexturePreviewUv(_cursor, out uv2) || !IsCursorOverPreviewViewport())
			{
				HideDecalPlacementPreview("uv miss", forceLog: false);
			}
			else
			{
				MirrorPaintTarget mirrorTarget3 = ResolveUvMirrorTarget(editableTexture, uv2, allowStatus: false);
				if (!TryGetActivePlacementStamp(out var stampTexture4, out var failureReason4))
				{
					HandlePlacementStampFailure(failureReason4);
				}
				else
				{
					ShowUvPlacementPreview(editableTexture, uv2, mirrorTarget3, stampTexture4, "TextureFallback");
				}
			}
		}

		private void HandlePlacementStampFailure(string failureReason)
		{
			if (_tool == EditorTool.Text && string.Equals(failureReason, "empty text", StringComparison.OrdinalIgnoreCase))
			{
				SetStatus("Enter text before stamping.", warn: false);
			}
			HideDecalPlacementPreview(failureReason, forceLog: false);
		}

		private bool IsPlacementTool(EditorTool tool)
		{
			if (tool != EditorTool.Decal && tool != EditorTool.Text)
			{
				return tool == EditorTool.Sticker;
			}
			return true;
		}

		private bool TryGetActivePlacementStamp(out Texture2D stampTexture, out string failureReason)
		{
			stampTexture = null;
			failureReason = string.Empty;
			if (_tool == EditorTool.Decal)
			{
				if ((Object)(object)_loadedDecal == (Object)null)
				{
					failureReason = "no selected decal";
					return false;
				}
				return TryGetEditedPlacementStamp(PlacementEditTarget.Decal, _loadedDecal, tintSticker: false, out stampTexture, out failureReason);
			}
			if (_tool == EditorTool.Text)
			{
				return TryGetTextStampTexture(out stampTexture, out failureReason);
			}
			if (_tool == EditorTool.Sticker)
			{
				if (!TryGetStickerStampTexture(_stickerShape, out var texture, out failureReason))
				{
					return false;
				}
				return TryGetEditedPlacementStamp(PlacementEditTarget.Sticker, texture, tintSticker: true, out stampTexture, out failureReason);
			}
			failureReason = "not a placement tool";
			return false;
		}

		private bool ShouldDelayWorldPlacementPreviewUntilIdle(Texture2D sourceTexture, RaycastHit hit, MirrorPaintTarget mirrorTarget)
		{
			//IL_002a: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			if (_tool != EditorTool.Decal && _tool != EditorTool.Sticker)
			{
				return false;
			}
			float unscaledTime = Time.unscaledTime;
			float num = (_lastPlacementPreviewCursorValid ? Vector2.Distance(_cursor, _lastPlacementPreviewCursor) : 0f);
			bool flag = _lastPlacementPreviewCursorValid && num > 2f;
			string text = BuildWorldPlacementPreviewIdleTargetKey(sourceTexture, hit, mirrorTarget);
			bool flag2 = !string.Equals(text, _lastPlacementPreviewIdleTargetKey, StringComparison.Ordinal);
			if (!_lastPlacementPreviewCursorValid || flag || flag2)
			{
				_lastPlacementPreviewCursor = _cursor;
				_lastPlacementPreviewCursorValid = true;
				_lastPlacementPreviewCursorMoveTime = unscaledTime;
				_lastPlacementPreviewIdleTargetKey = text;
				HideDecalPlacementPreview(flag ? "preview cursor moving" : "preview target changed", forceLog: false);
				string eventName = (flag ? "PlacementPreviewHiddenWhileMoving" : "PlacementPreviewWaitingForIdle");
				string reason = (flag ? "cursor moved" : (flag2 ? "target changed" : "cursor initialized"));
				LogPlacementPreviewIdleWait(eventName, reason, sourceTexture, hit, mirrorTarget, num, 0f);
				LogPlacementPreviewStampDeferred(reason, sourceTexture, hit, mirrorTarget, num, 0f);
				SetPlacementPreviewIdleStatus();
				return true;
			}
			float num2 = unscaledTime - _lastPlacementPreviewCursorMoveTime;
			if (num2 < 0.15f)
			{
				HideDecalPlacementPreview("preview waiting for idle", forceLog: false);
				LogPlacementPreviewIdleWait("PlacementPreviewWaitingForIdle", "idle delay", sourceTexture, hit, mirrorTarget, num, num2);
				LogPlacementPreviewStampDeferred("idle delay", sourceTexture, hit, mirrorTarget, num, num2);
				SetPlacementPreviewIdleStatus();
				return true;
			}
			return false;
		}

		private string BuildWorldPlacementPreviewIdleTargetKey(Texture2D sourceTexture, RaycastHit hit, MirrorPaintTarget mirrorTarget)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_012b: Unknown result type (might be due to invalid IL or missing references)
			Vector2Int val = (Vector2Int)(((Object)(object)sourceTexture != (Object)null) ? TexturePixel(sourceTexture, ((RaycastHit)(ref hit)).textureCoord) : new Vector2Int(-1, -1));
			int num = ((((Vector2Int)(ref val)).x >= 0) ? (((Vector2Int)(ref val)).x / 8) : (-1));
			int num2 = ((((Vector2Int)(ref val)).y >= 0) ? (((Vector2Int)(ref val)).y / 8) : (-1));
			int num3 = ((mirrorTarget.Enabled && mirrorTarget.Available) ? mirrorTarget.TriangleIndex : (-1));
			return $"{_tool}|suit={_selectedSuitId}|pixelBucket={num},{num2}|triangle={((RaycastHit)(ref hit)).triangleIndex}|mirror={mirrorTarget.Enabled}:{mirrorTarget.Available}:{num3}|size={Mathf.RoundToInt(CurrentPlacementSize())}|rot={Mathf.RoundToInt(CurrentPlacementRotation() * 10f)}|opacity={Mathf.RoundToInt(_brushOpacity * 1000f)}|stamp={CurrentPlacementName()}|color={ColorToHex(_brushColor)}|serial={_decalPreviewSerial}";
		}

		private void SetPlacementPreviewIdleStatus()
		{
			string text = ((_tool == EditorTool.Sticker) ? "sticker" : "decal");
			string text2 = "Hold still to preview " + text + ". Click/RT still stamps.";
			if (!_statusMessage.StartsWith(text2, StringComparison.OrdinalIgnoreCase))
			{
				SetStatus(text2, warn: false);
			}
		}

		private void ShowWorldPlacementPreview(Texture2D sourceTexture, RaycastHit hit, MirrorPaintTarget mirrorTarget, Texture2D stampTexture)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: 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_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: 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_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_worldAvatarRenderer == (Object)null || (Object)(object)_worldSourceRenderer == (Object)null || (Object)(object)sourceTexture == (Object)null || (Object)(object)stampTexture == (Object)null || (Object)(object)_worldPaintCollider == (Object)null)
			{
				HideDecalPlacementPreview("world dependencies missing", forceLog: false);
				return;
			}
			if (!EnsureDecalPreviewTexture(sourceTexture))
			{
				HideDecalPlacementPreview("preview texture failed", forceLog: true);
				return;
			}
			string text = BuildSurfacePlacementPreviewKey("WorldThirdPersonSurfaceDecal", sourceTexture, hit, mirrorTarget);
			TextSurfaceStampStats stats = default(TextSurfaceStampStats);
			TextSurfaceStampStats stats2 = default(TextSurfaceStampStats);
			bool flag = false;
			bool flag2 = !string.Equals(text, _lastDecalPreviewKey, StringComparison.Ordinal);
			if (!flag2)
			{
				LogPlacementPreviewReused(text, sourceTexture, hit, stampTexture);
			}
			else if (_decalPreviewVisible && _worldDecalPreviewApplied && Time.unscaledTime - _lastWorldPlacementPreviewRebuildTime < 0.05f)
			{
				LogPlacementPreviewThrottled(text, sourceTexture, hit, stampTexture);
				SetPlacementPreviewStatus(mirrorTarget);
				return;
			}
			if (flag2)
			{
				float realtimeSinceStartup = Time.realtimeSinceStartup;
				if (!CopySourceTextureToPlacementPreview(sourceTexture, "world placement preview"))
				{
					HideDecalPlacementPreview("preview source copy failed", forceLog: true);
					return;
				}
				HashSet<int> touchedPixels = ((mirrorTarget.Enabled && mirrorTarget.Available) ? new HashSet<int>() : null);
				bool num = CompositeDecalSurfaceStamp(_decalPreviewTexture, stampTexture, ((RaycastHit)(ref hit)).point, ((RaycastHit)(ref hit)).normal, CurrentPlacementRotation(), mirrored: false, Mathf.Clamp01(_brushOpacity * 0.62f), touchedPixels, out stats);
				bool flag3 = false;
				if (ShouldApplyMirror(sourceTexture, ((RaycastHit)(ref hit)).textureCoord, mirrorTarget) && TryGetMirrorWorldPlacement(mirrorTarget, out var point, out var normal))
				{
					flag3 = CompositeDecalSurfaceStamp(_decalPreviewTexture, stampTexture, point, normal, 0f - CurrentPlacementRotation(), mirrored: true, Mathf.Clamp01(_brushOpacity * 0.62f), touchedPixels, out stats2);
				}
				if (!num && !flag3)
				{
					HideDecalPlacementPreview("decal surface preview projected no pixels", forceLog: false);
					if (_tool == EditorTool.Sticker)
					{
						LogStickerSurfacePreviewSkipped(sourceTexture, hit, mirrorTarget, stampTexture, stats, stats2, "surface preview projected no pixels");
					}
					else
					{
						LogDecalSurfacePreviewSkipped(sourceTexture, hit, mirrorTarget, stampTexture, stats, stats2);
					}
					return;
				}
				_decalPreviewTexture.Apply(false, false);
				_lastDecalPreviewKey = text;
				_lastWorldPlacementPreviewRebuildTime = Time.unscaledTime;
				LogPlacementPreviewRebuildTiming(text, sourceTexture, stampTexture, (Time.realtimeSinceStartup - realtimeSinceStartup) * 1000f);
				flag = true;
			}
			Material val = EnsureWorldDecalPreviewMaterial(sourceTexture);
			if ((Object)(object)val == (Object)null)
			{
				HideDecalPlacementPreview("preview material failed", forceLog: true);
				return;
			}
			val.mainTexture = (Texture)(object)_decalPreviewTexture;
			Material[] array = BuildWorldProxyMaterials(_worldSourceRenderer);
			Material[] array2 = (Material[])(object)new Material[array.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array2[i] = ((array[i] == _worldHiddenSubmeshMaterial) ? array[i] : val);
			}
			((Renderer)_worldAvatarRenderer).sharedMaterials = array2;
			_worldDecalPreviewApplied = true;
			_decalPreviewVisible = true;
			_placementPreviewTool = _tool;
			if ((Object)(object)_uvDecalPreviewRect != (Object)null)
			{
				((Component)_uvDecalPreviewRect).gameObject.SetActive(false);
			}
			if ((Object)(object)_uvMirrorDecalPreviewRect != (Object)null)
			{
				((Component)_uvMirrorDecalPreviewRect).gameObject.SetActive(false);
			}
			SetPlacementPreviewStatus(mirrorTarget);
			if (flag)
			{
				if (_tool == EditorTool.Sticker)
				{
					LogStickerSurfacePreviewUpdated(sourceTexture, hit, mirrorTarget, stampTexture, stats, stats2);
				}
				else
				{
					LogDecalSurfacePreviewUpdated(sourceTexture, hit, mirrorTarget, stampTexture, stats, stats2);
				}
			}
		}

		private void ShowWorldTextPlacementPreview(Texture2D sourceTexture, RaycastHit hit, MirrorPaintTarget mirrorTarget, Texture2D stampTexture)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: 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_0263: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_worldAvatarRenderer == (Object)null || (Object)(object)_worldSourceRenderer == (Object)null || (Object)(object)sourceTexture == (Object)null || (Object)(object)stampTexture == (Object)null || (Object)(object)_worldPaintCollider == (Object)null)
			{
				HideDecalPlacementPreview("world text dependencies missing", forceLog: false);
				return;
			}
			if (!EnsureDecalPreviewTexture(sourceTexture))
			{
				HideDecalPlacementPreview("text preview texture failed", forceLog: true);
				return;
			}
			string text = BuildSurfacePlacementPreviewKey("WorldThirdPersonSurfaceText", sourceTexture, hit, mirrorTarget);
			TextSurfaceStampStats stats = default(TextSurfaceStampStats);
			TextSurfaceStampStats stats2 = default(TextSurfaceStampStats);
			bool flag = false;
			if (!string.Equals(text, _lastDecalPreviewKey, StringComparison.Ordinal))
			{
				_decalPreviewTexture.SetPixels32(sourceTexture.GetPixels32());
				HashSet<int> touchedPixels = ((mirrorTarget.Enabled && mirrorTarget.Available) ? new HashSet<int>() : null);
				bool num = CompositeTextSurfaceStamp(_decalPreviewTexture, stampTexture, ((RaycastHit)(ref hit)).point, ((RaycastHit)(ref hit)).normal, _textRotation, mirrored: false, Mathf.Clamp01(_brushOpacity * 0.62f), touchedPixels, out stats);
				bool flag2 = false;
				if (ShouldApplyMirror(sourceTexture, ((RaycastHit)(ref hit)).textureCoord, mirrorTarget) && TryGetMirrorWorldPlacement(mirrorTarget, out var point, out var normal))
				{
					flag2 = CompositeTextSurfaceStamp(_decalPreviewTexture, stampTexture, point, normal, 0f - _textRotation, mirrored: true, Mathf.Clamp01(_brushOpacity * 0.62f), touchedPixels, out stats2);
				}
				if (!num && !flag2)
				{
					HideDecalPlacementPreview("text surface preview projected no pixels", forceLog: false);
					LogTextSurfacePreviewSkipped(sourceTexture, hit, mirrorTarget, stampTexture, stats, stats2);
					return;
				}
				_decalPreviewTexture.Apply(false, false);
				_lastDecalPreviewKey = text;
				flag = true;
			}
			Material val = EnsureWorldDecalPreviewMaterial(sourceTexture);
			if ((Object)(object)val == (Object)null)
			{
				HideDecalPlacementPreview("text preview material failed", forceLog: true);
				return;
			}
			val.mainTexture = (Texture)(object)_decalPreviewTexture;
			Material[] array = BuildWorldProxyMaterials(_worldSourceRenderer);
			Material[] array2 = (Material[])(object)new Material[array.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array2[i] = ((array[i] == _worldHiddenSubmeshMaterial) ? array[i] : val);
			}
			((Renderer)_worldAvatarRenderer).sharedMaterials = array2;
			_worldDecalPreviewApplied = true;
			_decalPreviewVisible = true;
			_placementPreviewTool = _tool;
			if ((Object)(object)_uvDecalPreviewRect != (Object)null)
			{
				((Component)_uvDecalPreviewRect).gameObject.SetActive(false);
			}
			if ((Object)(object)_uvMirrorDecalPreviewRect != (Object)null)
			{
				((Component)_uvMirrorDecalPreviewRect).gameObject.SetActive(false);
			}
			SetPlacementPreviewStatus(mirrorTarget);
			if (flag)
			{
				LogTextSurfacePreviewUpdated(sourceTexture, hit, mirrorTarget, stampTexture, stats, stats2);
			}
		}

		private void ShowUvPlacementPreview(Texture2D sourceTexture, Vector2 uv, MirrorPaintTarget mirrorTarget, Texture2D stampTexture, string mode)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_uvDecalPreviewRect == (Object)null || (Object)(object)_uvDecalPreviewImage == (Object)null || (Object)(object)_previewViewportRect == (Object)null || (Object)(object)sourceTexture == (Object)null || (Object)(object)stampTexture == (Object)null)
			{
				HideDecalPlacementPreview("uv dependencies missing", forceLog: false);
				return;
			}
			RestoreWorldDecalPreviewMaterial();
			bool num = ConfigureUvPlacementPreview(_uvDecalPreviewRect, _uvDecalPreviewImage, sourceTexture, stampTexture, uv, mirrored: false);
			if (ShouldApplyMirror(sourceTexture, uv, mirrorTarget))
			{
				ConfigureUvPlacementPreview(_uvMirrorDecalPreviewRect, _uvMirrorDecalPreviewImage, sourceTexture, stampTexture, mirrorTarget.Uv, mirrored: true);
			}
			else if ((Object)(object)_uvMirrorDecalPreviewRect != (Object)null)
			{
				((Component)_uvMirrorDecalPreviewRect).gameObject.SetActive(false);
			}
			if (!num)
			{
				HideDecalPlacementPreview("uv preview target outside visible panel", forceLog: false);
				return;
			}
			_decalPreviewVisible = true;
			_placementPreviewTool = _tool;
			_lastDecalPreviewKey = BuildDecalPreviewKey(mode, sourceTexture, uv, mirrorTarget);
			SetPlacementPreviewStatus(mirrorTarget);
			LogPlacementPreviewUpdated(mode, sourceTexture, uv, mirrorTarget, stampTexture, force: false);
		}

		private bool ConfigureUvPlacementPreview(RectTransform previewRect, RawImage previewImage, Texture2D sourceTexture, Texture2D stampTexture, Vector2 uv, bool mirrored)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)previewRect == (Object)null || (Object)(object)previewImage == (Object)null || (Object)(object)_previewViewportRect == (Object)null || (Object)(object)sourceTexture == (Object)null || (Object)(object)stampTexture == (Object)null)
			{
				return false;
			}
			Rect rect = _previewViewportRect.rect;
			if (!TryTextureUvToPreviewLocal(uv, out var localPoint))
			{
				((Component)previewRect).gameObject.SetActive(false);
				return false;
			}
			float num = (mirrored ? (0f - CurrentPlacementRotation()) : CurrentPlacementRotation());
			Vector2 sizeDelta = ResolveUvPanelPlacementDisplaySize(sourceTexture, stampTexture, num, rect);
			previewImage.texture = (Texture)(object)stampTexture;
			((Graphic)previewImage).color = ((_tool == EditorTool.Text) ? new Color(_brushColor.r, _brushColor.g, _brushColor.b, mirrored ? 0.5f : 0.62f) : (mirrored ? new Color(1f, 1f, 1f, 0.5f) : new Color(1f, 1f, 1f, 0.62f)));
			((Graphic)previewImage).raycastTarget = false;
			previewImage.uvRect = (mirrored ? new Rect(1f, 0f, -1f, 1f) : new Rect(0f, 0f, 1f, 1f));
			previewRect.anchoredPosition = localPoint;
			previewRect.sizeDelta = sizeDelta;
			((Transform)previewRect).localRotation = Quaternion.Euler(0f, 0f, num);
			((Component)previewRect).gameObject.SetActive(true);
			return true;
		}

		private Vector2 ResolveUvPanelPlacementDisplaySize(Texture2D sourceTexture, Texture2D stampTexture, float visibleRotation, Rect rect)
		{
			//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_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_00ad: 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_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: 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)
			Rect uvPanelViewRect = GetUvPanelViewRect();
			Vector2 placementStampPixelSize = GetPlacementStampPixelSize(stampTexture);
			float num = Mathf.Clamp(placementStampPixelSize.x / Mathf.Max(1f, (float)((Texture)sourceTexture).width * ((Rect)(ref uvPanelViewRect)).width) * ((Rect)(ref rect)).width, 4f, ((Rect)(ref rect)).width * 1.5f);
			float num2 = Mathf.Clamp(placementStampPixelSize.y / Mathf.Max(1f, (float)((Texture)sourceTexture).height * ((Rect)(ref uvPanelViewRect)).height) * ((Rect)(ref rect)).height, 4f, ((Rect)(ref rect)).height * 1.5f);
			if (!TryResolveUvPanelPlacementFrame(sourceTexture, stampTexture, CurrentPlacementSize(), visibleRotation, mirrored: false, logDiagnostics: false, out var frame))
			{
				return new Vector2(num, num2);
			}
			Vector2 viewVector = default(Vector2);
			((Vector2)(ref viewVector))..ctor(frame.RightAxis.x * frame.Width / Mathf.Max(1f, (float)((Texture)sourceTexture).width * ((Rect)(ref uvPanelViewRect)).width), frame.RightAxis.y * frame.Width / Mathf.Max(1f, (float)((Texture)sourceTexture).height * ((Rect)(ref uvPanelViewRect)).height));
			Vector2 viewVector2 = new Vector2(frame.UpAxis.x * frame.Height / Mathf.Max(1f, (float)((Texture)sourceTexture).width * ((Rect)(ref uvPanelViewRect)).width), frame.UpAxis.y * frame.Height / Mathf.Max(1f, (float)((Texture)sourceTexture).height * ((Rect)(ref uvPanelViewRect)).height));
			Vector2 val = ViewVectorToPanelVector(viewVector, _uvPanelRotationQuarterTurns);
			Vector2 val2 = ViewVectorToPanelVector(viewVector2, _uvPanelRotationQuarterTurns);
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(val.x * ((Rect)(ref rect)).width, val.y * ((Rect)(ref rect)).height);
			Vector2 val4 = default(Vector2);
			((Vector2)(ref val4))..ctor(val2.x * ((Rect)(ref rect)).width, val2.y * ((Rect)(ref rect)).height);
			float num3 = Mathf.Clamp(((Vector2)(ref val3)).magnitude, 4f, ((Rect)(ref rect)).width * 1.5f);
			float num4 = Mathf.Clamp(((Vector2)(ref val4)).magnitude, 4f, ((Rect)(ref rect)).height * 1.5f);
			return new Vector2(num3, num4);
		}

		private bool EnsureDecalPreviewTexture(Texture2D sourceTexture)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Invalid comparison between Unknown and I4
			if ((Object)(object)sourceTexture == (Object)null)
			{
				return false;
			}
			if ((Object)(object)_decalPreviewTexture != (Object)null && ((Texture)_decalPreviewTexture).width == ((Texture)sourceTexture).width && ((Texture)_decalPreviewTexture).height == ((Texture)sourceTexture).height && (int)_decalPreviewTexture.format == 4)
			{
				return true;
			}
			if ((Object)(object)_decalPreviewTexture != (Object)null)
			{
				Object.Destroy((Object)(object)_decalPreviewTexture);
			}
			_decalPreviewTexture = new Texture2D(((Texture)sourceTexture).width, ((Texture)sourceTexture).height, (TextureFormat)4, false)
			{
				name = "DrawableSuitsDecalPlacementPreview",
				filterMode = ((Texture)sourceTexture).filterMode,
				wrapMode = (TextureWrapMode)1,
				hideFlags = (HideFlags)61
			};
			InvalidateDecalPreview("preview texture recreated");
			return true;
		}

		private bool CopySourceTextureToPlacementPreview(Texture2D sourceTexture, string context)
		{
			if ((Object)(object)sourceTexture == (Object)null || (Object)(object)_decalPreviewTexture == (Object)null)
			{
				return false;
			}
			try
			{
				Graphics.CopyTexture((Texture)(object)sourceTexture, (Texture)(object)_decalPreviewTexture);
				return true;
			}
			catch (Exception ex)
			{
				int num = ((Texture)sourceTexture).width * ((Texture)sourceTexture).height;
				if (_placementPreviewBasePixels == null || _placementPreviewBasePixels.Length != num || _placementPreviewBaseSource != sourceTexture || _placementPreviewBaseSerial != _decalPreviewSerial)
				{
					try
					{
						_placementPreviewBasePixels = sourceTexture.GetPixels32();
						_placementPreviewBaseSource = sourceTexture;
						_placementPreviewBaseSerial = _decalPreviewSerial;
					}
					catch (Exception exception)
					{
						DrawableSuitsDiagnostics.Exception($"PlacementPreview source read failed. context={context}; source={((Object)sourceTexture).name}; size={((Texture)sourceTexture).width}x{((Texture)sourceTexture).height}; copyException={ex.GetType().Name}: {ex.Message}", exception);
						return false;
					}
				}
				_decalPreviewTexture.SetPixels32(_placementPreviewBasePixels);
				if (Time.unscaledTime - _lastPlacementPreviewThrottleLogTime > 2f)
				{
					_lastPlacementPreviewThrottleLogTime = Time.unscaledTime;
					DrawableSuitsDiagnostics.Warn($"PlacementPreview source copy fallback. context={context}; source={((Object)sourceTexture).name}; preview={((Object)_decalPreviewTexture).name}; reason={ex.GetType().Name}: {ex.Message}; cachedPixels={_placementPreviewBasePixels.Length}");
				}
				return true;
			}
		}

		private void LogPlacementPreviewIdleWait(string eventName, string reason, Texture2D sourceTexture, RaycastHit hit, MirrorPaintTarget mirrorTarget, float cursorDelta, float idleTime)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			Vector2Int val = (Vector2Int)(((Object)(object)sourceTexture != (Object)null) ? TexturePixel(sourceTexture, ((RaycastHit)(ref hit)).textureCoord) : new Vector2Int(-1, -1));
			string text = $"{eventName}|{_tool}|{reason}|{((Vector2Int)(ref val)).x / 8},{((Vector2Int)(ref val)).y / 8}|{((RaycastHit)(ref hit)).triangleIndex}|{CurrentPlacementName()}|{Mathf.RoundToInt(CurrentPlacementSize())}|{Mathf.RoundToInt(CurrentPlacementRotation() * 10f)}";
			if (!string.Equals(text, _lastPlacementPreviewIdleLogKey, StringComparison.Ordinal) || !(Time.unscaledTime - _lastPlacementPreviewIdleLogTime < 0.75f))
			{
				_lastPlacementPreviewIdleLogKey = text;
				_lastPlacementPreviewIdleLogTime = Time.unscaledTime;
				DrawableSuitsDiagnostics.Info($"{eventName}: tool={_tool}; pointerSource={_pointerSource}; cursor={_cursor}; cursorDelta={cursorDelta:0.##}; idleTime={idleTime:0.###}; idleDelay={0.15f:0.###}; moveThresholdPx={2f:0.##}; target=WorldThirdPerson; uv={((RaycastHit)(ref hit)).textureCoord}; pixel={((Vector2Int)(ref val)).x},{((Vector2Int)(ref val)).y}; triangle={((RaycastHit)(ref hit)).triangleIndex}; mirror={DescribeMirrorTarget(sourceTexture, mirrorTarget)}; stampDeferred=True; reason={reason}");
			}
		}

		private void LogPlacementPreviewSkippedForModal()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			string text = DescribeOpenEditorModal();
			string text2 = $"PlacementPreviewSkippedForModal|tool={_tool}|modal={text}";
			if (!string.Equals(text2, _lastPlacementPreviewThrottleLogKey, StringComparison.Ordinal) || !(Time.unscaledTime - _lastPlacementPreviewThrottleLogTime < 0.75f))
			{
				_lastPlacementPreviewThrottleLogKey = text2;
				_lastPlacementPreviewThrottleLogTime = Time.unscaledTime;
				DrawableSuitsDiagnostics.Info($"PlacementPreviewSkippedForModal: tool={_tool}; modal={text}; pointerSource={_pointerSource}; cursor={_cursor}; suit={_selectedSuitId}");
			}
		}

		private void LogPlacementPreviewStampDeferred(string reason, Texture2D sourceTexture, RaycastHit hit, MirrorPaintTarget mirrorTarget, float cursorDelta, float idleTime)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_00ec: Unknown result type (might be due to invalid IL or missing references)
			Vector2Int val = (Vector2Int)(((Object)(object)sourceTexture != (Object)null) ? TexturePixel(sourceTexture, ((RaycastHit)(ref hit)).textureCoord) : new Vector2Int(-1, -1));
			string text = $"PlacementPreviewStampDeferred|tool={_tool}|reason={reason}|pixel={((Vector2Int)(ref val)).x / 8},{((Vector2Int)(ref val)).y / 8}|triangle={((RaycastHit)(ref hit)).triangleIndex}";
			if (!string.Equals(text, _lastPlacementPreviewThrottleLogKey, StringComparison.Ordinal) || !(Time.unscaledTime - _lastPlacementPreviewThrottleLogTime < 0.75f))
			{
				_lastPlacementPreviewThrottleLogKey = text;
				_lastPlacementPreviewThrottleLogTime = Time.unscaledTime;
				DrawableSuitsDiagnostics.Info($"PlacementPreviewStampDeferred: tool={_tool}; reason={reason}; cursorDelta={cursorDelta:0.##}; idleTime={idleTime:0.###}; idleDelay={0.15f:0.###}; target=WorldThirdPerson; uv={((RaycastHit)(ref hit)).textureCoord}; pixel={((Vector2Int)(ref val)).x},{((Vector2Int)(ref val)).y}; triangle={((RaycastHit)(ref hit)).triangleIndex}; mirror={DescribeMirrorTarget(sourceTexture, mirrorTarget)}; stampGenerated=False; suit={_selectedSuitId}");
			}
		}

		private void LogPlacementPreviewReused(string key, Texture2D sourceTexture, RaycastHit hit, Texture2D stampTexture)
		{
			//IL_0049: 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_007d: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			if (!string.Equals(key, _lastPlacementPreviewReuseLogKey, StringComparison.Ordinal) && !(Time.unscaledTime - _lastPlacementPreviewReuseLogTime < 0.75f))
			{
				_lastPlacementPreviewReuseLogKey = key;
				_lastPlacementPreviewReuseLogTime = Time.unscaledTime;
				Vector2Int val = (((Object)(object)sourceTexture != (Object)null) ? new Vector2Int(Mathf.RoundToInt(((RaycastHit)(ref hit)).textureCoord.x * (float)(((Texture)sourceTexture).width - 1)), Mathf.RoundToInt(((RaycastHit)(ref hit)).textureCoord.y * (float)(((Texture)sourceTexture).height - 1))) : new Vector2Int(-1, -1));
				DrawableSuitsDiagnostics.Info(string.Format("PlacementPreviewReused: tool={0}; pixel={1},{2}; stamp={3}; stampSize={4}x{5}; key={6}", _tool, ((Vector2Int)(ref val)).x, ((Vector2Int)(ref val)).y, ((stampTexture != null) ? ((Object)stampTexture).name : null) ?? "null", (stampTexture != null) ? ((Texture)stampTexture).width : 0, (stampTexture != null) ? ((Texture)stampTexture).height : 0, key.GetHashCode()));
			}
		}

		private void LogPlacementPreviewThrottled(string key, Texture2D sourceTexture, RaycastHit hit, Texture2D stampTexture)
		{
			//IL_0014: 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_0048: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			Vector2Int val = (((Object)(object)sourceTexture != (Object)null) ? new Vector2Int(Mathf.RoundToInt(((RaycastHit)(ref hit)).textureCoord.x * (float)(((Texture)sourceTexture).width - 1)), Mathf.RoundToInt(((RaycastHit)(ref hit)).textureCoord.y * (float)(((Texture)sourceTexture).height - 1))) : new Vector2Int(-1, -1));
			string text = string.Format("{0}|{1},{2}|{3}|{4}|{5}", _tool, ((Vector2Int)(ref val)).x, ((Vector2Int)(ref val)).y, ((stampTexture != null) ? ((Object)stampTexture).name : null) ?? "null", Mathf.RoundToInt(CurrentPlacementSize()), Mathf.RoundToInt(CurrentPlacementRotation()));
			if (!string.Equals(text, _lastPlacementPreviewThrottleLogKey, StringComparison.Ordinal) || !(Time.unscaledTime - _lastPlacementPreviewThrottleLogTime < 0.75f))
			{
				_lastPlacementPreviewThrottleLogKey = text;
				_lastPlacementPreviewThrottleLogTime = Time.unscaledTime;
				DrawableSuitsDiagnostics.Info(string.Format("PlacementPreviewThrottled: tool={0}; pixel={1},{2}; interval={3:0.###}; minInterval={4:0.###}; stamp={5}; stampSize={6}x{7}; key={8}", _tool, ((Vector2Int)(ref val)).x, ((Vector2Int)(ref val)).y, Time.unscaledTime - _lastWorldPlacementPreviewRebuildTime, 0.05f, ((stampTexture != null) ? ((Object)stampTexture).name : null) ?? "null", (stampTexture != null) ? ((Texture)stampTexture).width : 0, (stampTexture != null) ? ((Texture)stampTexture).height : 0, key.GetHashCode()));
			}
		}

		private void LogPlacementPreviewRebuildTiming(string key, Texture2D sourceTexture, Texture2D stampTexture, float elapsedMs)
		{
			string text = string.Format("{0}|{1}x{2}|{3}|{4}|{5}", _tool, (sourceTexture != null) ? ((Texture)sourceTexture).width : 0, (sourceTexture != null) ? ((Texture)sourceTexture).height : 0, ((stampTexture != null) ? ((Object)stampTexture).name : null) ?? "null", Mathf.RoundToInt(CurrentPlacementSize()), Mathf.RoundToInt(CurrentPlacementRotation()));
			if (!string.Equals(text, _lastPlacementPreviewRebuildLogKey, StringComparison.Ordinal) || !(Time.unscaledTime - _lastPlacementPreviewRebuildLogTime < 0.75f))
			{
				_lastPlacementPreviewRebuildLogKey = text;
				_lastPlacementPreviewRebuildLogTime = Time.unscaledTime;
				DrawableSuitsDiagnostics.Info(string.Format("PlacementPreviewIdleRebuilt: tool={0}; pointerSource={1}; source={2}; sourceSize={3}x{4}; stamp={5}; stampSize={6}x{7}; elapsedMs={8:0.##}; idleTime={9:0.###}; idleDelay={10:0.###}; key={11}", _tool, _pointerSource, ((sourceTexture != null) ? ((Object)sourceTexture).name : null) ?? "null", (sourceTexture != null) ? ((Texture)sourceTexture).width : 0, (sourceTexture != null) ? ((Texture)sourceTexture).height : 0, ((stampTexture != null) ? ((Object)stampTexture).name : null) ?? "null", (stampTexture != null) ? ((Texture)stampTexture).width : 0, (stampTexture != null) ? ((Texture)stampTexture).height : 0, elapsedMs, Time.unscaledTime - _lastPlacementPreviewCursorMoveTime, 0.15f, key.GetHashCode()));
			}
		}

		private Material EnsureWorldDecalPreviewMaterial(Texture2D sourceTexture)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			object obj = DrawableSuitsPlugin.Registry.GetRuntimeMaterial(_selectedSuitId);
			if (obj == null)
			{
				MeshRenderer worldAvatarRenderer = _worldAvatarRenderer;
				obj = ((worldAvatarRenderer != null) ? ((Renderer)worldAvatarRenderer).sharedMaterial : null);
				if (obj == null)
				{
					SkinnedMeshRenderer worldSourceRenderer = _worldSourceRenderer;
					obj = ((worldSourceRenderer != null) ? ((Renderer)worldSourceRenderer).sharedMaterial : null);
				}
			}
			Material val = (Material)obj;
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			if ((Object)(object)_worldDecalPreviewMaterial == (Object)null || (Object)(object)_worldDecalPreviewMaterial.shader != (Object)(object)val.shader)
			{
				if ((Object)(object)_worldDecalPreviewMaterial != (Object)null)
				{
					Object.Destroy((Object)(object)_worldDecalPreviewMaterial);
				}
				_worldDecalPreviewMaterial = new Material(val)
				{
					name = "DrawableSuitsWorldDecalPlacementPreviewMaterial",
					hideFlags = (HideFlags)61
				};
			}
			_worldDecalPreviewMaterial.mainTexture = (Texture)(object)(_decalPreviewTexture ?? sourceTexture);
			if (_worldDecalPreviewMaterial.HasProperty("_Color"))
			{
				_worldDecalPreviewMaterial.SetColor("_Color", Color.white);
			}
			return _worldDecalPreviewMaterial;
		}

		private void HideDecalPlacementPreview(string reason, bool forceLog)
		{
			bool num = _decalPreviewVisible || _worldDecalPreviewApplied || ((Object)(object)_uvDecalPreviewRect != (Object)null && ((Component)_uvDecalPreviewRect).gameObject.activeSelf) || ((Object)(object)_uvMirrorDecalPreviewRect != (Object)null && ((Component)_uvMirrorDecalPreviewRect).gameObject.activeSelf);
			if ((Object)(object)_uvDecalPreviewRect != (Object)null)
			{
				((Component)_uvDecalPreviewRect).gameObject.SetActive(false);
			}
			if ((Object)(object)_uvMirrorDecalPreviewRect != (Object)null)
			{
				((Component)_uvMirrorDecalPreviewRect).gameObject.SetActive(false);
			}
			RestoreWorldDecalPreviewMaterial();
			if (num)
			{
				RefreshTexturePanelPreview("placement preview hidden", forceLog: false);
			}
			_decalPreviewVisible = false;
			if (_statusMessage.StartsWith("Previewing decal", StringComparison.OrdinalIgnoreCase) || _statusMessage.StartsWith("Previewing text", StringComparison.OrdinalIgnoreCase) || _statusMessage.StartsWith("Previewing sticker", StringComparison.OrdinalIgnoreCase))
			{
				SetStatus(BuildReadinessStatus(), warn: false);
			}
			if (num || forceLog)
			{
				LogPlacementPreviewHidden(reason, forceLog);
			}
		}

		private void RestoreWorldDecalPreviewMaterial()
		{
			if (_worldDecalPreviewApplied)
			{
				if ((Object)(object)_worldAvatarRenderer != (Object)null && (Object)(object)_worldSourceRenderer != (Object)null)
				{
					((Renderer)_worldAvatarRenderer).sharedMaterials = BuildWorldProxyMaterials(_worldSourceRenderer);
				}
				_worldDecalPreviewApplied = false;
			}
		}

		private void DestroyDecalPlacementPreviewResources()
		{
			HideDecalPlacementPreview("destroy preview resources", forceLog: true);
			if ((Object)(object)_decalPreviewTexture != (Object)null)
			{
				Object.Destroy((Object)(object)_decalPreviewTexture);
				_decalPreviewTexture = null;
			}
			if ((Object)(object)_worldDecalPreviewMaterial != (Object)null)
			{
				Object.Destroy((Object)(object)_worldDecalPreviewMaterial);
				_worldDecalPreviewMaterial = null;
			}
			_lastDecalPreviewKey = string.Empty;
			_placementPreviewBasePixels = null;
			_placementPreviewBaseSource = null;
			_placementPreviewBaseSerial = -1;
		}

		private void InvalidateDecalPreview(string reason)
		{
			_decalPreviewSerial++;
			_lastDecalPreviewKey = string.Empty;
			_placementPreviewBaseSource = null;
			_placementPreviewBaseSerial = -1;
			ResetSettledPlacementPreviewState();
			if (_decalPreviewVisible)
			{
				LogDecalPreviewHidden("invalidated: " + reason, force: false);
			}
		}

		private void ResetSettledPlacementPreviewState()
		{
			//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)
			_lastPlacementPreviewCursorValid = false;
			_lastPlacementPreviewCursor = Vector2.zero;
			_lastPlacementPreviewCursorMoveTime = 0f;
			_lastPlacementPreviewIdleTargetKey = string.Empty;
			_lastPlacementPreviewIdleLogKey = string.Empty;
		}

		private string BuildDecalPreviewKey(string mode, Texture2D sourceTexture, Vector2 uv, MirrorPaintTarget mirrorTarget)
		{
			//IL_000c: 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_00fa: Unknown result type (might be due to invalid IL or missing references)
			int num = (((Object)(object)sourceTexture != (Object)null) ? Mathf.RoundToInt(uv.x * (float)(((Texture)sourceTexture).width - 1)) : (-1));
			int num2 = (((Object)(object)sourceTexture != (Object)null) ? Mathf.RoundToInt(uv.y * (float)(((Texture)sourceTexture).height - 1)) : (-1));
			return $"{_decalPreviewSerial}|{mode}|tool={_tool}|suit={_selectedSuitId}|pixel={num},{num2}|mirror={DescribeMirrorTarget(sourceTexture, mirrorTarget)}|size={Mathf.RoundToInt(CurrentPlacementSize())}|rot={Mathf.RoundToInt(CurrentPlacementRotation() * 10f)}|opacity={Mathf.RoundToInt(_brushOpacity * 1000f)}|stamp={CurrentPlacementName()}|stampKey={_textStampTextureKey}|color={ColorToHex(_brushColor)}|texture={((sourceTexture != null) ? ((Texture)sourceTexture).width : 0)}x{((sourceTexture != null) ? ((Texture)sourceTexture).height : 0)}";
		}

		private string BuildSurfacePlacementPreviewKey(string mode, Texture2D sourceTexture, RaycastHit hit, MirrorPaintTarget mirrorTarget)
		{
			//IL_000e: 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_0057: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			int num = (((Object)(object)sourceTexture != (Object)null) ? Mathf.RoundToInt(((RaycastHit)(ref hit)).textureCoord.x * (float)(((Texture)sourceTexture).width - 1)) : (-1));
			int num2 = (((Object)(object)sourceTexture != (Object)null) ? Mathf.RoundToInt(((RaycastHit)(ref hit)).textureCoord.y * (float)(((Texture)sourceTexture).height - 1)) : (-1));
			string text = $"{Mathf.RoundToInt(((RaycastHit)(ref hit)).point.x * 80f)},{Mathf.RoundToInt(((RaycastHit)(ref hit)).point.y * 80f)},{Mathf.RoundToInt(((RaycastHit)(ref hit)).point.z * 80f)}";
			string text2 = $"{Mathf.RoundToInt(((RaycastHit)(ref hit)).normal.x * 24f)},{Mathf.RoundToInt(((RaycastHit)(ref hit)).normal.y * 24f)},{Mathf.RoundToInt(((RaycastHit)(ref hit)).normal.z * 24f)}";
			return $"{_decalPreviewSerial}|{mode}|tool={_tool}|suit={_selectedSuitId}|pixel={num},{num2}|triangle={((RaycastHit)(ref hit)).triangleIndex}|point={text}|normal={text2}|mirror={DescribeMirrorTarget(sourceTexture, mirrorTarget)}|size={Mathf.RoundToInt(CurrentPlacementSize())}|rot={Mathf.RoundToInt(CurrentPlacementRotation() * 10f)}|opacity={Mathf.RoundToInt(_brushOpacity * 1000f)}|stamp={CurrentPlacementName()}|stampKey={_textStampTextureKey}|color={ColorToHex(_brushColor)}|texture={((sourceTexture != null) ? ((Texture)sourceTexture).width : 0)}x{((sourceTexture != null) ? ((Texture)sourceTexture).height : 0)}";
		}

		private void SetPlacementPreviewStatus(MirrorPaintTarget mirrorTarget)
		{
			string text = ((_tool == EditorTool.Text) ? "text" : ((_tool == EditorTool.Sticker) ? "sticker" : "decal"));
			if (mirrorTarget.Enabled && !mirrorTarget.Available)
			{
				if (!_statusMessage.StartsWith("Previewing " + text + ". Mirror target not found", StringComparison.OrdinalIgnoreCase))
				{
					SetStatus("Previewing " + text + ". Mirror target not found; stamp affects primary only.", warn: false);
				}
			}
			else if (!_statusMessage.StartsWith("Previewing " + text, StringComparison.OrdinalIgnoreCase))
			{
				SetStatus("Previewing " + text + ". Click/RT to stamp.", warn: false);
			}
		}

		private Vector2 GetPlacementStampPixelSize(Texture2D stampTexture)
		{
			//IL_004b: 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 (_tool == EditorTool.Text && (Object)(object)stampTexture != (Object)null)
			{
				float num = Mathf.Max(1f, _textSize);
				float num2 = (float)((Texture)stampTexture).width / Mathf.Max(1f, (float)((Texture)stampTexture).height);
				return new Vector2(Mathf.Max(1f, num * num2), num);
			}
			float num3 = ((_tool == EditorTool.Sticker) ? _stickerSize : _decalSize);
			return new Vector2(Mathf.Max(1f, num3), Mathf.Max(1f, num3));
		}

		private string CurrentPlacementName()
		{
			return _tool switch
			{
				EditorTool.Text => $"text:{NormalizeTextStampValue(_textStampValue).Length}", 
				EditorTool.Sticker => $"sticker:{_stickerShape}:edit={_stickerPlacementEdit.Revision}", 
				_ => $"{CurrentDecalName()}:edit={_decalPlacementEdit.Revision}", 
			};
		}

		private bool TryGetEditedPlacementStamp(PlacementEditTarget target, Texture2D source, bool tintSticker, out Texture2D texture, out string failureReason)
		{
			texture = null;
			failureReason = string.Empty;
			if ((Object)(object)source == (Object)null)
			{
				failureReason = "missing placement source";
				return false;
			}
			PlacementEditState placementEditState = GetPlacementEditState(target);
			if (placementEditState == null)
			{
				failureReason = "invalid placement edit target";
				return false;
			}
			if (target == PlacementEditTarget.Decal && placementEditState.IsDefault)
			{
				texture = source;
				return true;
			}
			string text = BuildPlacementStampKey(target, source, tintSticker, placementEditState, "full", 0);
			if (target == PlacementEditTarget.Decal && (Object)(object)_editedDecalStampTexture != (Object)null && string.Equals(_editedDecalStampKey, text, StringComparison.Ordinal))
			{
				texture = _editedDecalStampTexture;
				return true;
			}
			if (target == PlacementEditTarget.Sticker && (Object)(object)_editedStickerStampTexture != (Object)null && string.Equals(_editedStickerStampKey, text, StringComparison.Ordinal))
			{
				texture = _editedStickerStampTexture;
				return true;
			}
			if (!TryGenerateEditedPlacementStamp(target, source, tintSticker, placementEditState, 0, preferCpuSourcePixels: false, out var texture2, out failureReason, out var _))
			{
				return false;
			}
			if (target == PlacementEditTarget.Decal)
			{
				if ((Object)(object)_editedDecalStampTexture != (Object)null)
				{
					Object.Destroy((Object)(object)_editedDecalStampTexture);
				}
				_editedDecalStampTexture = texture2;
				_editedDecalStampKey = text;
			}
			else
			{
				if ((Object)(object)_editedStickerStampTexture != (Object)null)
				{
					Object.Destroy((Object)(object)_editedStickerStampTexture);
				}
				_editedStickerStampTexture = texture2;
				_editedStickerStampKey = text;
			}
			texture = texture2;
			LogPlacementEditedStampGenerated(target, source, placementEditState, texture2, cacheHit: false);
			return true;
		}

		private bool TryGetEditedPlacementPreviewStamp(PlacementEditTarget target, Texture2D source, bool tintSticker, out Texture2D texture, out string failureReason, out bool cacheHit, out bool cpuPixelSamplingUsed)
		{
			texture = null;
			failureReason = string.Empty;
			cacheHit = false;
			cpuPixelSamplingUsed = false;
			if ((Object)(object)source == (Object)null)
			{
				failureReason = "missing placement source";
				return false;
			}
			PlacementEditState placementEditState = GetPlacementEditState(target);
			if (placementEditState == null)
			{
				failureReason = "invalid placement edit target";
				return false;
			}
			if (target == PlacementEditTarget.Decal && placementEditState.IsDefault)
			{
				texture = source;
				cacheHit = true;
				return true;
			}
			string text = BuildPlacementStampKey(target, source, tintSticker, placementEditState, "preview", 160);
			if (target == PlacementEditTarget.Decal && (Object)(object)_editedDecalPreviewStampTexture != (Object)null && string.Equals(_editedDecalPreviewStampKey, text, StringComparison.Ordinal))
			{
				texture = _editedDecalPreviewStampTexture;
				cacheHit = true;
				cpuPixelSamplingUsed = true;
				return true;
			}
			if (target == PlacementEditTarget.Sticker && (Object)(object)_editedStickerPreviewStampTexture != (Object)null && string.Equals(_editedStickerPreviewStampKey, text, StringComparison.Ordinal))
			{
				texture = _editedStickerPreviewStampTexture;
				cacheHit = true;
				cpuPixelSamplingUsed = true;
				return true;
			}
			if (!TryGenerateEditedPlacementStamp(target, source, tintSticker, placementEditState, 160, preferCpuSourcePixels: true, out var texture2, out failureReason, out cpuPixelSamplingUsed))
			{
				return false;
			}
			if (target == PlacementEditTarget.Decal)
			{
				if ((Object)(object)_editedDecalPreviewStampTexture != (Object)null)
				{
					Object.Destroy((Object)(object)_editedDecalPreviewStampTexture);
				}
				_editedDecalPreviewStampTexture = texture2;
				_editedDecalPreviewStampKey = text;
			}
			else
			{
				if ((Object)(object)_editedStickerPreviewStampTexture != (Object)null)
				{
					Object.Destroy((Object)(object)_editedStickerPreviewStampTexture);
				}
				_editedStickerPreviewStampTexture = texture2;
				_editedStickerPreviewStampKey = text;
			}
			texture = texture2;
			return true;
		}

		private bool TryUpdateFastDecalEditPreview(Texture2D source, PlacementEditState state, string reason, float startedAt, out string failureReason)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			failureReason = string.Empty;
			if ((Object)(object)source == (Object)null)
			{
				failureReason = "missing decal source";
				return false;
			}
			if (state == null)
			{
				failureReason = "missing decal edit state";
				return false;
			}
			if (state.IsDefault)
			{
				_placementEditPreviewImage.texture = (Texture)(object)source;
				((Graphic)_placementEditPreviewImage).color = Color.white;
				FitPlacementEditPreview(source);
				SetPlacementEditStatus("No temporary edits applied.");
				LogDecalEditPreviewFastCacheHit(source, state, source, reason, generatedPreviewCache: false, cpuPixelSamplingUsed: false, (Time.realtimeSinceStartup - startedAt) * 1000f);
				return true;
			}
			int placementEditPreviewMaxDimension = GetPlacementEditPreviewMaxDimension();
			string text = BuildPlacementStampKey(PlacementEditTarget.Decal, source, tintSticker: false, state, "modalPreview", placementEditPreviewMaxDimension);
			if ((Object)(object)_editedDecalPreviewStampTexture != (Object)null && string.Equals(_editedDecalPreviewStampKey, text, StringComparison.Ordinal))
			{
				_placementEditPreviewImage.texture = (Texture)(object)_editedDecalPreviewStampTexture;
				((Graphic)_placementEditPreviewImage).color = Color.white;
				FitPlacementEditPreview(_editedDecalPreviewStampTexture);
				SetPlacementEditStatus("Temporary edit preview ready.");
				LogDecalEditPreviewFastCacheHit(source, state, _editedDecalPreviewStampTexture, reason, generatedPreviewCache: true, cpuPixelSamplingUsed: true, (Time.realtimeSinceStartup - startedAt) * 1000f);
				return true;
			}
			if (!TryGenerateFastDecalEditPreview(source, state, placementEditPreviewMaxDimension, out var texture, out var sourceCacheHit, out var textureReused, out var elapsedMs, out failureReason))
			{
				return false;
			}
			_editedDecalPreviewStampKey = text;
			_placementEditPreviewImage.texture = (Texture)(object)texture;
			((Graphic)_placementEditPreviewImage).color = Color.white;
			FitPlacementEditPreview(texture);
			SetPlacementEditStatus("Temporary edit preview ready.");
			LogDecalEditPreviewFastUpdated(source, state, texture, reason, sourceCacheHit, textureReused, elapsedMs);
			return true;
		}

		private int GetPlacementEditPreviewMaxDimension()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_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_0035: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = Vector2.zero;
			if ((Object)(object)_placementEditPreviewFrameRect != (Object)null)
			{
				Rect rect = _placementEditPreviewFrameRect.rect;
				val = ((Rect)(ref rect)).size;
				if (val.x <= 1f || val.y <= 1f)
				{
					val = _placementEditPreviewFrameRect.sizeDelta;
				}
			}
			float num = ((val.x > 1f && val.y > 1f) ? Mathf.Min(val.x - 16f, val.y - 16f) : 160f);
			return Mathf.Clamp(Mathf.RoundToInt(Mathf.Max(48f, num)), 64, 160);
		}

		private bool TryGenerateFastDecalEditPreview(Texture2D source, PlacementEditState state, int maxOutputDimension, out Texture2D texture, out bool sourceCacheHit, out bool textureReused, out float elapsedMs, out string failureReason)
		{
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Expected O, but got Unknown
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			texture = null;
			sourceCacheHit = false;
			textureReused = false;
			elapsedMs = 0f;
			failureReason = string.Empty;
			if ((Object)(object)source == (Object)null || state == null)
			{
				failureReason = "missing decal edit source";
				return false;
			}
			if (!TryGetPlacementSourcePixels(PlacementEditTarget.Decal, source, out var pixels, out var width, out var height, out var cacheHit, out failureReason))
			{
				return false;
			}
			sourceCacheHit = cacheHit;
			if (!TryGenerateEditedDecalPixels(pixels, width, height, PlacementEditSnapshot.From(state), Mathf.Clamp((SystemInfo.maxTextureSize > 0) ? SystemInfo.maxTextureSize : 2048, 256, 8192), maxOutputDimension, _editedDecalPreviewPixelBuffer, out var outputPixels, out var outputWidth, out var outputHeight, out failureReason))
			{
				elapsedMs = (Time.realtimeSinceStartup - realtimeSinceStartup) * 1000f;
				return false;
			}
			_editedDecalPreviewPixelBuffer = outputPixels;
			if ((Object)(object)_editedDecalPreviewStampTexture != (Object)null && ((Texture)_editedDecalPreviewStampTexture).width == outputWidth && ((Texture)_editedDecalPreviewStampTexture).height == outputHeight)
			{
				texture = _editedDecalPreviewStampTexture;
				textureReused = true;
			}
			else
			{
				if ((Object)(object)_editedDecalPreviewStampTexture != (Object)null)
				{
					Object.Destroy((Object)(object)_editedDecalPreviewStampTexture);
				}
				texture = new Texture2D(outputWidth, outputHeight, (TextureFormat)4, false)
				{
					name = "DrawableSuitsEditedDecalPreview",
					filterMode = (FilterMode)1,
					wrapMode = (TextureWrapMode)1,
					hideFlags = (HideFlags)61
				};
				_editedDecalPreviewStampTexture = texture;
			}
			texture.SetPixels32(outputPixels);
			texture.Apply(false, false);
			elapsedMs = (Time.realtimeSinceStartup - realtimeSinceStartup) * 1000f;
			return true;
		}

		private string BuildPlacementStampKey(PlacementEditTarget target, Texture2D source, bool tintSticker, PlacementEditState state, string quality, int maxDimension)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			string text = (tintSticker ? ColorToHex(_brushColor) : "source");
			return $"{target}|quality={quality}|max={maxDimension}|source={((Object)source).name}|size={((Texture)source).width}x{((Texture)source).height}|state={state.Key()}|tint={tintSticker}:{text}";
		}

		private bool TryGenerateEditedPlacementStamp(PlacementEditTarget target, Texture2D source, bool tintSticker, PlacementEditState state, int maxOutputDimension, bool preferCpuSourcePixels, out Texture2D texture, out string failureReason, out bool cpuPixelSamplingUsed)
		{
			//IL_0067: 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_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Expected O, but got Unknown
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			texture = null;
			failureReason = string.Empty;
			cpuPixelSamplingUsed = false;
			if ((Object)(object)source == (Object)null)
			{
				failureReason = "missing source texture";
				return false;
			}
			try
			{
				float minSize = Mathf.Max(new float[3]
				{
					1f / (float)Mathf.Max(1, ((Texture)source).width),
					1f / (float)Mathf.Max(1, ((Texture)source).height),
					0.01f
				});
				Rect val = state.CropRect(minSize);
				int num = Mathf.Max(1, Mathf.RoundToInt(((Rect)(ref val)).width * (float)((Texture)source).width));
				int num2 = Mathf.Max(1, Mathf.RoundToInt(((Rect)(ref val)).height * (float)((Texture)source).height));
				int num3 = Mathf.Clamp((SystemInfo.maxTextureSize > 0) ? SystemInfo.maxTextureSize : 2048, 256, 8192);
				float num4 = Mathf.Max(1f, (float)num * Mathf.Max(0.01f, state.StretchX));
				float num5 = Mathf.Max(1f, (float)num2 * Mathf.Max(0.01f, state.StretchY));
				float num6 = 1f;
				if (maxOutputDimension > 0)
				{
					num6 = Mathf.Min(1f, (float)maxOutputDimension / Mathf.Max(num4, num5));
				}
				int num7 = Mathf.Clamp(Mathf.RoundToInt(num4 * num6), 1, num3);
				int num8 = Mathf.Clamp(Mathf.RoundToInt(num5 * num6), 1, num3);
				Color32[] pixels = null;
				int width = 0;
				int height = 0;
				if (preferCpuSourcePixels)
				{
					if (!TryGetPlacementSourcePixels(target, source, out pixels, out width, out height, out var _, out failureReason))
					{
						return false;
					}
					cpuPixelSamplingUsed = true;
				}
				Color32[] array = (Color32[])(object)new Color32[num7 * num8];
				for (int i = 0; i < num8; i++)
				{
					float num9 = ((float)i + 0.5f) / Mathf.Max(1f, (float)num8);
					if (state.FlipY)
					{
						num9 = 1f - num9;
					}
					float num10 = ((Rect)(ref val)).yMin + num9 * ((Rect)(ref val)).height;
					for (int j = 0; j < num7; j++)
					{
						float num11 = ((float)j + 0.5f) / Mathf.Max(1f, (float)num7);
						if (state.FlipX)
						{
							num11 = 1f - num11;
						}
						float num12 = ((Rect)(ref val)).xMin + num11 * ((Rect)(ref val)).width;
						Color val2 = (cpuPixelSamplingUsed ? SamplePlacementSourceBilinear(pixels, width, height, num12, num10) : source.GetPixelBilinear(Mathf.Clamp01(num12), Mathf.Clamp01(num10)));
						if (tintSticker)
						{
							((Color)(ref val2))..ctor(_brushColor.r, _brushColor.g, _brushColor.b, val2.a);
						}
						val2 = ApplyPlacementFilter(val2, state);
						array[i * num7 + j] = Color32.op_Implicit(val2);
					}
				}
				texture = new Texture2D(num7, num8, (TextureFormat)4, false)
				{
					name = $"DrawableSuitsEdited{target}Stamp",
					filterMode = (FilterMode)1,
					wrapMode = (TextureWrapMode)1,
					hideFlags = (HideFlags)61
				};
				texture.SetPixels32(array);
				texture.Apply(false, false);
				return true;
			}
			catch (Exception ex)
			{
				failureReason = ex.Message;
				DrawableSuitsDiagnostics.Exception($"PlacementEditedStampGenerated failed. target={target}; source={((Object)source).name}; size={((Texture)source).width}x{((Texture)source).height}", ex);
				return false;
			}
		}

		private static bool TryGenerateEditedDecalPixels(Color32[] sourcePixels, int sourceWidth, int sourceHeight, PlacementEditSnapshot state, int maxTextureSize, int maxOutputDimension, Color32[] reusableOutputPixels, out Color32[] outputPixels, out int outputWidth, out int outputHeight, out string failureReason)
		{
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			outputPixels = null;
			outputWidth = 0;
			outputHeight = 0;
			failureReason = string.Empty;
			if (sourcePixels == null || sourceWidth <= 0 || sourceHeight <= 0 || sourcePixels.Length < sourceWidth * sourceHeight)
			{
				failureReason = "Decal source pixel data was invalid.";
				return false;
			}
			if (state == null)
			{
				state = new PlacementEditSnapshot();
			}
			double num = Math.Max(Math.Max(1.0 / (double)Math.Max(1, sourceWidth), 1.0 / (double)Math.Max(1, sourceHeight)), 0.01);
			double num2 = Clamp01Double(state.CropLeft);
			double num3 = Clamp01Double(state.CropRight);
			double num4 = Clamp01Double(state.CropBottom);
			double num5 = Clamp01Double(state.CropTop);
			if (num2 + num3 > 1.0 - num)
			{
				double num6 = (1.0 - num) / Math.Max(0.0001, num2 + num3);
				num2 *= num6;
				num3 *= num6;
			}
			if (num4 + num5 > 1.0 - num)
			{
				double num7 = (1.0 - num) / Math.Max(0.0001, num4 + num5);
				num4 *= num7;
				num5 *= num7;
			}
			double num8 = Math.Max(num, 1.0 - num2 - num3);
			double num9 = Math.Max(num, 1.0 - num4 - num5);
			int num10 = Math.Max(1, RoundPositiveToInt(num8 * (double)sourceWidth));
			int num11 = Math.Max(1, RoundPositiveToInt(num9 * (double)sourceHeight));
			maxTextureSize = ClampInt((maxTextureSize > 0) ? maxTextureSize : 2048, 256, 8192);
			double num12 = Math.Max(1.0, (double)num10 * Math.Max(0.01, state.StretchX));
			double num13 = Math.Max(1.0, (double)num11 * Math.Max(0.01, state.StretchY));
			double num14 = 1.0;
			if (maxOutputDimension > 0)
			{
				num14 = Math.Min(1.0, (double)maxOutputDimension / Math.Max(num12, num13));
			}
			outputWidth = ClampInt(RoundPositiveToInt(num12 * num14), 1, maxTextureSize);
			outputHeight = ClampInt(RoundPositiveToInt(num13 * num14), 1, maxTextureSize);
			int num15 = outputWidth * outputHeight;
			outputPixels = (Color32[])((reusableOutputPixels != null && reusableOutputPixels.Length == num15) ? ((Array)reusableOutputPixels) : ((Array)new Color32[num15]));
			for (int i = 0; i < outputHeight; i++)
			{
				double num16 = ((double)i + 0.5) / Math.Max(1.0, outputHeight);
				if (state.FlipY)
				{
					num16 = 1.0 - num16;
				}
				double v = num4 + num16 * num9;
				for (int j = 0; j < outputWidth; j++)
				{
					double num17 = ((double)j + 0.5) / Math.Max(1.0, outputWidth);
					if (state.FlipX)
					{
						num17 = 1.0 - num17;
					}
					double u = num2 + num17 * num8;
					Color32 color = SamplePlacementSourceBilinearColor32(sourcePixels, sourceWidth, sourceHeight, u, v);
					outputPixels[i * outputWidth + j] = ApplyPlacementFilterToColor32(color, state);
				}
			}
			return true;
		}

		private static Color32 SamplePlacementSourceBilinearColor32(Color32[] pixels, int width, int height, double u, double v)
		{
			//IL_0017: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: 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_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: 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_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			if (pixels == null || width <= 0 || height <= 0 || pixels.Length < width * height)
			{
				return new Color32((byte)0, (byte)0, (byte)0, (byte)0);
			}
			double num = Clamp01Double(u) * (double)Math.Max(0, width - 1);
			double num2 = Clamp01Double(v) * (double)Math.Max(0, height - 1);
			int num3 = ClampInt((int)Math.Floor(num), 0, width - 1);
			int num4 = ClampInt((int)Math.Floor(num2), 0, height - 1);
			int num5 = Math.Min(width - 1, num3 + 1);
			int num6 = Math.Min(height - 1, num4 + 1);
			double t = num - (double)num3;
			double t2 = num2 - (double)num4;
			Color32 val = pixels[num4 * width + num3];
			Color32 val2 = pixels[num4 * width + num5];
			Color32 val3 = pixels[num6 * width + num3];
			Color32 val4 = pixels[num6 * width + num5];
			double a = LerpDouble((int)val.r, (int)val2.r, t);
			double b = LerpDouble((int)val3.r, (int)val4.r, t);
			double a2 = LerpDouble((int)val.g, (int)val2.g, t);
			double b2 = LerpDouble((int)val3.g, (int)val4.g, t);
			double a3 = LerpDouble((int)val.b, (int)val2.b, t);
			double b3 = LerpDouble((int)val3.b, (int)val4.b, t);
			double a4 = LerpDouble((int)val.a, (int)val2.a, t);
			double b4 = LerpDouble((int)val3.a, (int)val4.a, t);
			return new Color32(ByteFrom255(LerpDouble(a, b, t2)), ByteFrom255(LerpDouble(a2, b2, t2)), ByteFrom255(LerpDouble(a3, b3, t2)), ByteFrom255(LerpDouble(a4, b4, t2)));
		}

		private static Color32 ApplyPlacementFilterToColor32(Color32 color, PlacementEditSnapshot state)
		{
			//IL_000b: 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_001f: 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_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			if (state == null || !state.HasActiveFilters)
			{
				return color;
			}
			double r = (double)(int)color.r / 255.0;
			double g = (double)(int)color.g / 255.0;
			double b = (double)(int)color.b / 255.0;
			ApplyPlacementFilterAmount(ref r, ref g, ref b, state.GrayscaleAmount, GrayscaleR(r, g, b), GrayscaleR(r, g, b), GrayscaleR(r, g, b));
			ApplyPlacementFilterAmount(ref r, ref g, ref b, state.SepiaAmount, Clamp01Double(r * 0.393 + g * 0.769 + b * 0.189), Clamp01Double(r * 0.349 + g * 0.686 + b * 0.168), Clamp01Double(r * 0.272 + g * 0.534 + b * 0.131));
			ApplyPlacementFilterAmount(ref r, ref g, ref b, state.InvertAmount, 1.0 - r, 1.0 - g, 1.0 - b);
			ApplyPlacementFilterAmount(ref r, ref g, ref b, state.BrightnessAmount, r + 0.35, g + 0.35, b + 0.35);
			ApplyPlacementFilterAmount(ref r, ref g, ref b, state.ContrastAmount, (r - 0.5) * 2.25 + 0.5, (g - 0.5) * 2.25 + 0.5, (b - 0.5) * 2.25 + 0.5);
			double num = GrayscaleR(r, g, b);
			ApplyPlacementFilterAmount(ref r, ref g, ref b, state.SaturationAmount, num + (r - num) * 2.75, num + (g - num) * 2.75, num + (b - num) * 2.75);
			if (state.HueShiftAmount > 0.0001f)
			{
				RgbToHsv(r, g, b, out var h, out var s, out var v);
				HsvToRgb(Repeat01(h + Clamp01Double(state.HueShiftAmount) * 0.5), s, v, out r, out g, out b);
			}
			return new Color32(ToByte01(r), ToByte01(g), ToByte01(b), color.a);
		}

		private static void ApplyPlacementFilterAmount(ref double r, ref double g, ref double b, float amount, double filteredR, double filteredG, double filteredB)
		{
			double num = Clamp01Double(amount);
			if (!(num <= 0.0001))
			{
				r = Clamp01Double(LerpDouble(r, filteredR, num));
				g = Clamp01Double(LerpDouble(g, filteredG, num));
				b = Clamp01Double(LerpDouble(b, filteredB, num));
			}
		}

		private static double GrayscaleR(double r, double g, double b)
		{
			return r * 0.299 + g * 0.587 + b * 0.114;
		}

		private static void RgbToHsv(double r, double g, double b, out double h, out double s, out double v)
		{
			double num = Math.Max(r, Math.Max(g, b));
			double num2 = Math.Min(r, Math.Min(g, b));
			v = num;
			double num3 = num - num2;
			s = ((num <= 1E-06) ? 0.0 : (num3 / num));
			if (num3 <= 1E-06)
			{
				h = 0.0;
				return;
			}
			if (Math.Abs(num - r) <= 1E-06)
			{
				h = (g - b) / num3 % 6.0;
			}
			else if (Math.Abs(num - g) <= 1E-06)
			{
				h = (b - r) / num3 + 2.0;
			}
			else
			{
				h = (r - g) / num3 + 4.0;
			}
			h /= 6.0;
			h = Repeat01(h);
		}

		private static void HsvToRgb(double h, double s, double v, out double r, out double g, out double b)
		{
			h = Repeat01(h);
			s = Clamp01Double(s);
			v = Clamp01Double(v);
			double num = v * s;
			double num2 = num * (1.0 - Math.Abs(h * 6.0 % 2.0 - 1.0));
			double num3 = v - num;
			switch ((int)Math.Floor(h * 6.0))
			{
			case 0:
				r = num;
				g = num2;
				b = 0.0;
				break;
			case 1:
				r = num2;
				g = num;
				b = 0.0;
				break;
			case 2:
				r = 0.0;
				g = num;
				b = num2;
				break;
			case 3:
				r = 0.0;
				g = num2;
				b = num;
				break;
			case 4:
				r = num2;
				g = 0.0;
				b = num;
				break;
			default:
				r = num;
				g = 0.0;
				b = num2;
				break;
			}
			r = Clamp01Double(r + num3);
			g = Clamp01Double(g + num3);
			b = Clamp01Double(b + num3);
		}

		private static double Repeat01(double value)
		{
			value -= Math.Floor(value);
			if (!(value < 0.0))
			{
				return value;
			}
			return value + 1.0;
		}

		private static double Clamp01Double(double value)
		{
			if (value <= 0.0)
			{
				return 0.0;
			}
			if (!(value >= 1.0))
			{
				return value;
			}
			return 1.0;
		}

		private static int ClampInt(int value, int min, int max)
		{
			if (value < min)
			{
				return min;
			}
			if (value <= max)
			{
				return value;
			}
			return max;
		}

		private static int RoundPositiveToInt(double value)
		{
			return (int)Math.Floor(Math.Max(0.0, value) + 0.5);
		}

		private static double LerpDouble(double a, double b, double t)
		{
			return a + (b - a) * t;
		}

		private static byte ByteFrom255(double value)
		{
			return (byte)ClampInt(RoundPositiveToInt(value), 0, 255);
		}

		private static byte ToByte01(double value)
		{
			return ByteFrom255(Clamp01Double(value) * 255.0);
		}

		private bool TryGetPlacementSourcePixels(PlacementEditTarget target, Texture2D source, out Color32[] pixels, out int width, out int height, out bool cacheHit, out string failureReason)
		{
			pixels = null;
			width = 0;
			height = 0;
			cacheHit = false;
			failureReason = string.Empty;
			if ((Object)(object)source == (Object)null)
			{
				failureReason = "missing source texture";
				return false;
			}
			if (_placementSourcePixelCache != null && _placementSourcePixelCache.Target == target && _placementSourcePixelCache.Source == source && _placementSourcePixelCache.Width == ((Texture)source).width && _placementSourcePixelCache.Height == ((Texture)source).height && _placementSourcePixelCache.Pixels != null && _placementSourcePixelCache.Pixels.Length == ((Texture)source).width * ((Texture)source).height)
			{
				pixels = _placementSourcePixelCache.Pixels;
				width = _placementSourcePixelCache.Width;
				height = _placementSourcePixelCache.Height;
				cacheHit = true;
				LogPlacementSourcePixels(target, source, cacheHit: true, 0f);
				return true;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			Color32[] pixels2;
			try
			{
				pixels2 = source.GetPixels32();
			}
			catch (Exception exception)
			{
				failureReason = "Source texture pixels could not be read.";
				DrawableSuitsDiagnostics.Exception($"PlacementSourcePixelsCached failed. target={target}; source={((Object)source).name}; size={((Texture)source).width}x{((Texture)source).height}", exception);
				return false;
			}
			if (pixels2 == null || pixels2.Length != ((Texture)source).width * ((Texture)source).height)
			{
				failureReason = "Source texture pixel data was invalid.";
				DrawableSuitsDiagnostics.Warn($"PlacementSourcePixelsCached failed. target={target}; source={((Object)source).name}; size={((Texture)source).width}x{((Texture)source).height}; pixels={((pixels2 != null) ? pixels2.Length : 0)}");
				return false;
			}
			_placementSourcePixelCache = new PlacementSourcePixelCache
			{
				Target = target,
				Source = source,
				SourceName = (((Object)source).name ?? string.Empty),
				Width = ((Texture)source).width,
				Height = ((Texture)source).height,
				Pixels = pixels2
			};
			pixels = pixels2;
			width = ((Texture)source).width;
			height = ((Texture)source).height;
			LogPlacementSourcePixels(target, source, cacheHit: false, (Time.realtimeSinceStartup - realtimeSinceStartup) * 1000f);
			return true;
		}

		private void ClearPlacementSourcePixelCache(PlacementEditTarget target, string reason)
		{
			if (_placementSourcePixelCache != null && (target == PlacementEditTarget.None || _placementSourcePixelCache.Target == target))
			{
				DrawableSuitsDiagnostics.Info($"PlacementSourcePixelsCacheCleared: target={_placementSourcePixelCache.Target}; source={_placementSourcePixelCache.SourceName}; size={_placementSourcePixelCache.Width}x{_placementSourcePixelCache.Height}; reason={reason}; suit={_selectedSuitId}");
				_placementSourcePixelCache = null;
			}
		}

		private void LogPlacementSourcePixels(PlacementEditTarget target, Texture2D source, bool cacheHit, float elapsedMs)
		{
			string text = (cacheHit ? "PlacementSourcePixelsCacheHit" : "PlacementSourcePixelsCached");
			string text2 = $"{text}|target={target}|source={((source != null) ? ((Object)source).name : null)}|size={((source != null) ? ((Texture)source).width : 0)}x{((source != null) ? ((Texture)source).height : 0)}";
			if (!cacheHit || !(Time.unscaledTime - _lastPlacementSourcePixelsLogTime < 0.75f) || !string.Equals(text2, _lastPlacementSourcePixelsLogKey, StringComparison.Ordinal))
			{
				_lastPlacementSourcePixelsLogTime = Time.unscaledTime;
				_lastPlacementSourcePixelsLogKey = text2;
				DrawableSuitsDiagnostics.Info($"{text}: target={target}; source={GetPlacementEditSourceName(target)}; texture={((source != null) ? ((Object)source).name : null)}; size={((source != null) ? ((Texture)source).width : 0)}x{((source != null) ? ((Texture)source).height : 0)}; pixelCount={(((Object)(object)source != (Object)null) ? (((Texture)source).width * ((Texture)source).height) : 0)}; elapsedMs={elapsedMs:0.##}; suit={_selectedSuitId}");
			}
		}

		private static Color SamplePlacementSourceBilinear(Color32[] pixels, int width, int height, float u, float v)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: 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_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			if (pixels == null || width <= 0 || height <= 0 || pixels.Length < width * height)
			{
				return Color.clear;
			}
			float num = Mathf.Clamp01(u) * (float)Mathf.Max(0, width - 1);
			float num2 = Mathf.Clamp01(v) * (float)Mathf.Max(0, height - 1);
			int num3 = Mathf.Clamp(Mathf.FloorToInt(num), 0, width - 1);
			int num4 = Mathf.Clamp(Mathf.FloorToInt(num2), 0, height - 1);
			int num5 = Mathf.Min(width - 1, num3 + 1);
			int num6 = Mathf.Min(height - 1, num4 + 1);
			float num7 = num - (float)num3;
			float num8 = num2 - (float)num4;
			Color32 val = pixels[num4 * width + num3];
			Color32 val2 = pixels[num4 * width + num5];
			Color32 val3 = pixels[num6 * width + num3];
			Color32 val4 = pixels[num6 * width + num5];
			float num9 = Mathf.Lerp((float)(int)val.r, (float)(int)val2.r, num7);
			float num10 = Mathf.Lerp((float)(int)val3.r, (float)(int)val4.r, num7);
			float num11 = Mathf.Lerp((float)(int)val.g, (float)(int)val2.g, num7);
			float num12 = Mathf.Lerp((float)(int)val3.g, (float)(int)val4.g, num7);
			float num13 = Mathf.Lerp((float)(int)val.b, (float)(int)val2.b, num7);
			float num14 = Mathf.Lerp((float)(int)val3.b, (float)(int)val4.b, num7);
			float num15 = Mathf.Lerp((float)(int)val.a, (float)(int)val2.a, num7);
			float num16 = Mathf.Lerp((float)(int)val3.a, (float)(int)val4.a, num7);
			return new Color(Mathf.Lerp(num9, num10, num8) / 255f, Mathf.Lerp(num11, num12, num8) / 255f, Mathf.Lerp(num13, num14, num8) / 255f, Mathf.Lerp(num15, num16, num8) / 255f);
		}

		private static Color ApplyPlacementFilter(Color color, PlacementEditState state)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_0076: 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_0094: 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_00ac: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: 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_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			if (state == null || !state.HasActiveFilters)
			{
				return color;
			}
			Color color2 = default(Color);
			((Color)(ref color2))..ctor(color.r, color.g, color.b, 1f);
			ApplyPlacementFilterAmount(ref color2, state.GrayscaleAmount, ToGrayscale(color2));
			ApplyPlacementFilterAmount(ref color2, state.SepiaAmount, ToSepia(color2));
			ApplyPlacementFilterAmount(ref color2, state.InvertAmount, new Color(1f - color2.r, 1f - color2.g, 1f - color2.b, 1f));
			ApplyPlacementFilterAmount(ref color2, state.BrightnessAmount, new Color(color2.r + 0.35f, color2.g + 0.35f, color2.b + 0.35f, 1f));
			ApplyPlacementFilterAmount(ref color2, state.ContrastAmount, AdjustContrast(color2, 2.25f));
			ApplyPlacementFilterAmount(ref color2, state.SaturationAmount, AdjustSaturation(color2, 2.75f));
			if (state.HueShiftAmount > 0.0001f)
			{
				color2 = ShiftHue(color2, Mathf.Clamp01(state.HueShiftAmount) * 0.5f);
			}
			return new Color(Mathf.Clamp01(color2.r), Mathf.Clamp01(color2.g), Mathf.Clamp01(color2.b), color.a);
		}

		private static void ApplyPlacementFilterAmount(ref Color color, float amount, Color filtered)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_0036: 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)
			amount = Mathf.Clamp01(amount);
			if (!(amount <= 0.0001f))
			{
				Color val = Color.Lerp(color, filtered, amount);
				color = new Color(Mathf.Clamp01(val.r), Mathf.Clamp01(val.g), Mathf.Clamp01(val.b), 1f);
			}
		}

		private static Color ToGrayscale(Color color)
		{
			//IL_0000: 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_0019: 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)
			float num = color.r * 0.299f + color.g * 0.587f + color.b * 0.114f;
			return new Color(num, num, num, 1f);
		}

		private static Color ToSepia(Color color)
		{
			//IL_0000: 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_0019: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: 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_0086: Unknown result type (might be due to invalid IL or missing references)
			return new Color(Mathf.Clamp01(color.r * 0.393f + color.g * 0.769f + color.b * 0.189f), Mathf.Clamp01(color.r * 0.349f + color.g * 0.686f + color.b * 0.168f), Mathf.Clamp01(color.r * 0.272f + color.g * 0.534f + color.b * 0.131f), 1f);
		}

		private static Color AdjustContrast(Color color, float factor)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: 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)
			return new Color(Mathf.Clamp01((color.r - 0.5f) * factor + 0.5f), Mathf.Clamp01((color.g - 0.5f) * factor + 0.5f), Mathf.Clamp01((color.b - 0.5f) * factor + 0.5f), 1f);
		}

		private static Color AdjustSaturation(Color color, float factor)
		{
			//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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			Color val = ToGrayscale(color);
			return new Color(Mathf.Clamp01(val.r + (color.r - val.r) * factor), Mathf.Clamp01(val.g + (color.g - val.g) * factor), Mathf.Clamp01(val.b + (color.b - val.b) * factor), 1f);
		}

		private static Color ShiftHue(Color color, float amount)
		{
			//IL_0000: 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)
			float num2 = default(float);
			float num3 = default(float);
			float num = default(float);
			Color.RGBToHSV(color, ref num, ref num2, ref num3);
			num = Mathf.Repeat(num + amount, 1f);
			return Color.HSVToRGB(num, num2, num3);
		}

		private bool TryGetTextStampTexture(out Texture2D texture, out string failureReason)
		{
			texture = null;
			string text = NormalizeTextStampValue(_textStampValue);
			if (string.IsNullOrWhiteSpace(text))
			{
				failureReason = "empty text";
				return false;
			}
			if (_textStampRenderer == null)
			{
				_textStampRenderer = new TextStampRenderer();
			}
			texture = _textStampRenderer.GetOrRender(text, out _textStampTextureKey, out failureReason);
			_textStampTexture = texture;
			return (Object)(object)texture != (Object)null;
		}

		private bool TryGetStickerStampTexture(StickerShape shape, out Texture2D texture, out string failureReason)
		{
			failureReason = string.Empty;
			if (_stickerStampTextures.TryGetValue(shape, out texture) && (Object)(object)texture != (Object)null)
			{
				return true;
			}
			texture = GenerateStickerStampTexture(shape);
			if ((Object)(object)texture == (Object)null)
			{
				failureReason = "failed to generate " + StickerShapeDisplayName(shape);
				return false;
			}
			_stickerStampTextures[shape] = texture;
			DrawableSuitsDiagnostics.Info($"StickerStampGenerated: shape={shape}; display={StickerShapeDisplayName(shape)}; texture={((Texture)texture).width}x{((Texture)texture).height}");
			return true;
		}

		private static Texture2D GenerateStickerStampTexture(StickerShape shape)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(256, 256, (TextureFormat)4, false)
			{
				name = $"DrawableSuitsSticker_{shape}",
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1,
				hideFlags = (HideFlags)61
			};
			Color32[] array = (Color32[])(object)new Color32[65536];
			int num = 9;
			for (int i = 0; i < 256; i++)
			{
				for (int j = 0; j < 256; j++)
				{
					int num2 = 0;
					for (int k = 0; k < 3; k++)
					{
						for (int l = 0; l < 3; l++)
						{
							float num3 = ((float)j + ((float)l + 0.5f) / 3f) / 256f * 2f - 1f;
							float num4 = ((float)i + ((float)k + 0.5f) / 3f) / 256f * 2f - 1f;
							if (IsInsideStickerShape(shape, new Vector2(num3, num4)))
							{
								num2++;
							}
						}
					}
					int num5 = Mathf.RoundToInt(255f * (float)num2 / (float)num);
					array[i * 256 + j] = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, (byte)num5);
				}
			}
			val.SetPixels32(array);
			val.Apply(false, false);
			return val;
		}

		private static bool IsInsideStickerShape(StickerShape shape, Vector2 p)
		{
			//IL_0000: 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_007b: 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_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Abs(p.x);
			float num2 = Mathf.Abs(p.y);
			switch (shape)
			{
			case StickerShape.Circle:
				return ((Vector2)(ref p)).sqrMagnitude <= 0.6724f;
			case StickerShape.Square:
				if (num <= 0.78f)
				{
					return num2 <= 0.78f;
				}
				return false;
			case StickerShape.Triangle:
				return PointInPolygon(p, StickerTriangleVertices);
			case StickerShape.Diamond:
				return num + num2 <= 1.05f;
			case StickerShape.Star:
				return IsInsideStar(p);
			case StickerShape.Heart:
				return IsInsideHeart(p);
			case StickerShape.Arrow:
				return PointInPolygon(p, StickerArrowVertices);
			case StickerShape.LightningBolt:
				return PointInPolygon(p, StickerLightningVertices);
			case StickerShape.Plus:
				if (!(num <= 0.22f) || !(num2 <= 0.8f))
				{
					if (num2 <= 0.22f)
					{
						return num <= 0.8f;
					}
					return false;
				}
				return true;
			case StickerShape.Ring:
			{
				float magnitude = ((Vector2)(ref p)).magnitude;
				if (magnitude >= 0.52f)
				{
					return magnitude <= 0.82f;
				}
				return false;
			}
			case StickerShape.Crescent:
			{
				Vector2 val = p + new Vector2(0.12f, 0f);
				bool num3 = ((Vector2)(ref val)).sqrMagnitude <= 0.6083999f;
				val = p - new Vector2(0.22f, 0.08f);
				bool flag = ((Vector2)(ref val)).sqrMagnitude <= 0.5184f;
				if (num3)
				{
					return !flag;
				}
				return false;
			}
			case StickerShape.Shield:
				return PointInPolygon(p, StickerShieldVertices);
			default:
				return false;
			}
		}

		private static bool IsInsideStar(Vector2 p)
		{
			//IL_001c: 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)
			float magnitude = ((Vector2)(ref p)).magnitude;
			if (magnitude > 0.9f)
			{
				return false;
			}
			if (magnitude < 0.26f)
			{
				return true;
			}
			float num = Mathf.Atan2(p.y, p.x) - MathF.PI / 2f;
			float num2 = MathF.PI * 2f / 5f;
			float num3 = Mathf.Abs(Mathf.Repeat(num + num2 * 0.5f, num2) - num2 * 0.5f);
			float num4 = Mathf.Lerp(0.9f, 0.36f, num3 / (num2 * 0.5f));
			return magnitude <= num4;
		}

		private static bool IsInsideHeart(Vector2 p)
		{
			//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)
			float num = p.x * 1.15f;
			float num2 = (p.y + 0.08f) * 1.18f;
			float num3 = num * num + num2 * num2 - 0.58f;
			return num3 * num3 * num3 - num * num * num2 * num2 * num2 <= 0f;
		}

		private static bool PointInPolygon(Vector2 point, Vector2[] polygon)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_0074: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			int num = 0;
			int num2 = polygon.Length - 1;
			while (num < polygon.Length)
			{
				Vector2 val = polygon[num];
				Vector2 val2 = polygon[num2];
				float num3 = val2.y - val.y;
				if (Mathf.Abs(num3) < 0.0001f)
				{
					num3 = ((num3 < 0f) ? (-0.0001f) : 0.0001f);
				}
				if (val.y > point.y != val2.y > point.y && point.x < (val2.x - val.x) * (point.y - val.y) / num3 + val.x)
				{
					flag = !flag;
				}
				num2 = num++;
			}
			return flag;
		}

		private void InvalidateTextStampTexture(string reason)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			_textStampTextureKey = string.Empty;
			_textStampTexture = null;
			DrawableSuitsDiagnostics.Info($"TextStampTexture invalidated. reason={reason}; textLength={NormalizeTextStampValue(_textStampValue).Length}; color={ColorToHex(_brushColor)}");
		}

		private static string NormalizeTextStampValue(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			string text = value.Replace('\r', ' ').Replace('\n', ' ');
			if (text.Length > 64)
			{
				return text.Substring(0, 64);
			}
			return text;
		}

		private void LogPlacementPreviewUpdated(string mode, Texture2D texture, Vector2 uv, MirrorPaintTarget mirrorTarget, Texture2D stampTexture, bool force)
		{
			//IL_000c: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			if (_tool == EditorTool.Text)
			{
				LogTextPreviewUpdated(mode, texture, uv, mirrorTarget, stampTexture, force);
			}
			else if (_tool == EditorTool.Sticker)
			{
				LogStickerPreviewUpdated(mode, texture, uv, mirrorTarget, stampTexture, force);
			}
			else
			{
				LogDecalPreviewUpdated(mode, texture, uv, mirrorTarget, force);
			}
		}

		private void LogDecalPreviewUpdated(string mode, Texture2D texture, Vector2 uv, MirrorPaintTarget mirrorTarget, bool force)
		{
			//IL_000a: 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_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)texture == (Object)null))
			{
				int num = Mathf.RoundToInt(uv.x * (float)(((Texture)texture).width - 1));
				int num2 = Mathf.RoundToInt(uv.y * (float)(((Texture)texture).height - 1));
				object[] obj = new object[10]
				{
					mode,
					num,
					num2,
					DescribeMirrorTarget(texture, mirrorTarget),
					Mathf.RoundToInt(_decalSize),
					Mathf.RoundToInt(_decalRotation),
					_brushOpacity,
					CurrentDecalName(),
					null,
					null
				};
				Texture2D decalPreviewTexture = _decalPreviewTexture;
				obj[8] = ((decalPreviewTexture != null) ? ((Texture)decalPreviewTexture).width : 0);
				Texture2D decalPreviewTexture2 = _decalPreviewTexture;
				obj[9] = ((decalPreviewTexture2 != null) ? ((Texture)decalPreviewTexture2).height : 0);
				string text = string.Format("updated|mode={0}|pixel={1},{2}|mirror={3}|size={4}|rotation={5}|opacity={6:0.##}|decal={7}|preview={8}x{9}", obj);
				if (force || !(Time.unscaledTime - _lastDecalPreviewLogTime < 0.5f) || !string.Equals(text, _lastDecalPreviewLogKey, StringComparison.Ordinal))
				{
					_lastDecalPreviewLogTime = Time.unscaledTime;
					_lastDecalPreviewLogKey = text;
					DrawableSuitsDiagnostics.Info($"DecalPreviewUpdated: {text}; uv={uv}; pointerSource={_pointerSource}; cursor={_cursor}");
				}
			}
		}

		private void LogDecalSurfacePreviewUpdated(Texture2D texture, RaycastHit hit, MirrorPaintTarget mirrorTarget, Texture2D stampTexture, TextSurfaceStampStats primaryStats, TextSurfaceStampStats mirrorStats)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)texture == (Object)null) && !((Object)(object)stampTexture == (Object)null))
			{
				Vector2Int val = TexturePixel(texture, ((RaycastHit)(ref hit)).textureCoord);
				string text = $"surfacePreview|pixel={((Vector2Int)(ref val)).x},{((Vector2Int)(ref val)).y}|mirror={DescribeMirrorTarget(texture, mirrorTarget)}|decal={CurrentDecalName()}|size={Mathf.RoundToInt(_decalSize)}|rotation={Mathf.RoundToInt(_decalRotation)}|opacity={_brushOpacity:0.##}|stampTexture={((Texture)stampTexture).width}x{((Texture)stampTexture).height}|primaryWritten={primaryStats.WrittenPixels}|mirrorWritten={mirrorStats.WrittenPixels}|primaryCells={primaryStats.RasterizedCells}|mirrorCells={mirrorStats.RasterizedCells}|primarySeams={primaryStats.SeamSkippedCells}|mirrorSeams={mirrorStats.SeamSkippedCells}";
				if (!(Time.unscaledTime - _lastDecalPreviewLogTime < 0.5f) || !string.Equals(text, _lastDecalPreviewLogKey, StringComparison.Ordinal))
				{
					_lastDecalPreviewLogTime = Time.unscaledTime;
					_lastDecalPreviewLogKey = text;
					DrawableSuitsDiagnostics.Info($"DecalSurfacePreviewUpdated: {text}; hitPoint={((RaycastHit)(ref hit)).point}; hitNormal={((RaycastHit)(ref hit)).normal}; primarySamples={primaryStats.ProjectionSamples}; primaryHits={primaryStats.SurfaceHits}; primaryAlpha={primaryStats.AlphaPixels}; primarySkipped={primaryStats.SkippedPixels}; primaryOffSuit={primaryStats.OffSuitSamples}; primaryWorldSize={primaryStats.WorldWidth:0.###}x{primaryStats.WorldHeight:0.###}; mirrorSamples={mirrorStats.ProjectionSamples}; mirrorHits={mirrorStats.SurfaceHits}; mirrorAlpha={mirrorStats.AlphaPixels}; mirrorSkipped={mirrorStats.SkippedPixels}; mirrorOffSuit={mirrorStats.OffSuitSamples}; mirrorWorldSize={mirrorStats.WorldWidth:0.###}x{mirrorStats.WorldHeight:0.###}; pointerSource={_pointerSource}; cursor={_cursor}");
				}
			}
		}

		private void LogDecalSurfacePreviewSkipped(Texture2D texture, RaycastHit hit, MirrorPaintTarget mirrorTarget, Texture2D stampTexture, TextSurfaceStampStats primaryStats, TextSurfaceStampStats mirrorStats)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)texture == (Object)null))
			{
				Vector2Int val = TexturePixel(texture, ((RaycastHit)(ref hit)).textureCoord);
				string text = $"surfacePreviewSkipped|pixel={((Vector2Int)(ref val)).x},{((Vector2Int)(ref val)).y}|mirror={DescribeMirrorTarget(texture, mirrorTarget)}|decal={CurrentDecalName()}|stampTexture={((stampTexture != null) ? ((Texture)stampTexture).width : 0)}x{((stampTexture != null) ? ((Texture)stampTexture).height : 0)}|primarySkipped={primaryStats.SkippedPixels}|mirrorSkipped={mirrorStats.SkippedPixels}|primaryCells={primaryStats.RasterizedCells}|mirrorCells={mirrorStats.RasterizedCells}";
				if (!(Time.unscaledTime - _lastDecalPreviewLogTime < 0.75f) || !string.Equals(text, _lastDecalPreviewLogKey, StringComparison.Ordinal))
				{
					_lastDecalPreviewLogTime = Time.unscaledTime;
					_lastDecalPreviewLogKey = text;
					DrawableSuitsDiagnostics.Info($"DecalSurfacePreviewSkipped: {text}; hitPoint={((RaycastHit)(ref hit)).point}; hitNormal={((RaycastHit)(ref hit)).normal}; primarySamples={primaryStats.ProjectionSamples}; primaryHits={primaryStats.SurfaceHits}; primaryOffSuit={primaryStats.OffSuitSamples}; primarySeams={primaryStats.SeamSkippedCells}; mirrorSamples={mirrorStats.ProjectionSamples}; mirrorHits={mirrorStats.SurfaceHits}; mirrorOffSuit={mirrorStats.OffSuitSamples}; mirrorSeams={mirrorStats.SeamSkippedCells}; pointerSource={_pointerSource}; cursor={_cursor}");
				}
			}
		}

		private void LogTextPreviewUpdated(string mode, Texture2D texture, Vector2 uv, MirrorPaintTarget mirrorTarget, Texture2D stampTexture, bool force)
		{
			//IL_0014: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)texture == (Object)null) && !((Object)(object)stampTexture == (Object)null))
			{
				int num = Mathf.RoundToInt(uv.x * (float)(((Texture)texture).width - 1));
				int num2 = Mathf.RoundToInt(uv.y * (float)(((Texture)texture).height - 1));
				Vector2 placementStampPixelSize = GetPlacementStampPixelSize(stampTexture);
				string text = $"updated|mode={mode}|pixel={num},{num2}|mirror={DescribeMirrorTarget(texture, mirrorTarget)}|textLength={NormalizeTextStampValue(_textStampValue).Length}|fontSize={Mathf.RoundToInt(_textSize)}|rotation={Mathf.RoundToInt(_textRotation)}|color={ColorToHex(_brushColor)}|opacity={_brushOpacity:0.##}|stampTexture={((Texture)stampTexture).width}x{((Texture)stampTexture).height}|stampSize={Mathf.RoundToInt(placementStampPixelSize.x)}x{Mathf.RoundToInt(placementStampPixelSize.y)}";
				if (force || !(Time.unscaledTime - _lastTextPreviewLogTime < 0.5f) || !string.Equals(text, _lastTextPreviewLogKey, StringComparison.Ordinal))
				{
					_lastTextPreviewLogTime = Time.unscaledTime;
					_lastTextPreviewLogKey = text;
					DrawableSuitsDiagnostics.Info($"TextPreviewUpdated: {text}; uv={uv}; pointerSource={_pointerSource}; cursor={_cursor}");
				}
			}
		}

		private void LogTextSurfacePreviewUpdated(Texture2D texture, RaycastHit hit, MirrorPaintTarget mirrorTarget, Texture2D stampTexture, TextSurfaceStampStats primaryStats, TextSurfaceStampStats mirrorStats)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)texture == (Object)null) && !((Object)(object)stampTexture == (Object)null))
			{
				Vector2Int val = TexturePixel(texture, ((RaycastHit)(ref hit)).textureCoord);
				string text = $"surfacePreview|pixel={((Vector2Int)(ref val)).x},{((Vector2Int)(ref val)).y}|mirror={DescribeMirrorTarget(texture, mirrorTarget)}|textLength={NormalizeTextStampValue(_textStampValue).Length}|fontSize={Mathf.RoundToInt(_textSize)}|rotation={Mathf.RoundToInt(_textRotation)}|color={ColorToHex(_brushColor)}|opacity={_brushOpacity:0.##}|stampTexture={((Texture)stampTexture).width}x{((Texture)stampTexture).height}|primaryWritten={primaryStats.WrittenPixels}|mirrorWritten={mirrorStats.WrittenPixels}";
				if (!(Time.unscaledTime - _lastTextPreviewLogTime < 0.5f) || !string.Equals(text, _lastTextPreviewLogKey, StringComparison.Ordinal))
				{
					_lastTextPreviewLogTime = Time.unscaledTime;
					_lastTextPreviewLogKey = text;
					DrawableSuitsDiagnostics.Info($"TextSurfacePreviewUpdated: {text}; hitPoint={((RaycastHit)(ref hit)).point}; hitNormal={((RaycastHit)(ref hit)).normal}; primaryAlpha={primaryStats.AlphaPixels}; primarySkipped={primaryStats.SkippedPixels}; primaryWorldSize={primaryStats.WorldWidth:0.###}x{primaryStats.WorldHeight:0.###}; mirrorAlpha={mirrorStats.AlphaPixels}; mirrorSkipped={mirrorStats.SkippedPixels}; mirrorWorldSize={mirrorStats.WorldWidth:0.###}x{mirrorStats.WorldHeight:0.###}; pointerSource={_pointerSource}; cursor={_cursor}");
				}
			}
		}

		private void LogTextSurfacePreviewSkipped(Texture2D texture, RaycastHit hit, MirrorPaintTarget mirrorTarget, Texture2D stampTexture, TextSurfaceStampStats primaryStats, TextSurfaceStampStats mirrorStats)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)texture == (Object)null))
			{
				Vector2Int val = TexturePixel(texture, ((RaycastHit)(ref hit)).textureCoord);
				string text = $"surfacePreviewSkipped|pixel={((Vector2Int)(ref val)).x},{((Vector2Int)(ref val)).y}|mirror={DescribeMirrorTarget(texture, mirrorTarget)}|textLength={NormalizeTextStampValue(_textStampValue).Length}|stampTexture={((stampTexture != null) ? ((Texture)stampTexture).width : 0)}x{((stampTexture != null) ? ((Texture)stampTexture).height : 0)}|primarySkipped={primaryStats.SkippedPixels}|mirrorSkipped={mirrorStats.SkippedPixels}";
				if (!(Time.unscaledTime - _lastTextPreviewLogTime < 0.75f) || !string.Equals(text, _lastTextPreviewLogKey, StringComparison.Ordinal))
				{
					_lastTextPreviewLogTime = Time.unscaledTime;
					_lastTextPreviewLogKey = text;
					DrawableSuitsDiagnostics.Info($"TextSurfacePreviewSkipped: {text}; hitPoint={((RaycastHit)(ref hit)).point}; hitNormal={((RaycastHit)(ref hit)).normal}; pointerSource={_pointerSource}; cursor={_cursor}");
				}
			}
		}

		private void LogStickerPreviewUpdated(string mode, Texture2D texture, Vector2 uv, MirrorPaintTarget mirrorTarget, Texture2D stampTexture, bool force)
		{
			//IL_0014: 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_00a5: 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_0141: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)texture == (Object)null) && !((Object)(object)stampTexture == (Object)null))
			{
				int num = Mathf.RoundToInt(uv.x * (float)(((Texture)texture).width - 1));
				int num2 = Mathf.RoundToInt(uv.y * (float)(((Texture)texture).height - 1));
				string text = $"updated|mode={mode}|pixel={num},{num2}|mirror={DescribeMirrorTarget(texture, mirrorTarget)}|shape={_stickerShape}|size={Mathf.RoundToInt(_stickerSize)}|rotation={Mathf.RoundToInt(_stickerRotation)}|color={ColorToHex(_brushColor)}|opacity={_brushOpacity:0.##}|stampTexture={((Texture)stampTexture).width}x{((Texture)stampTexture).height}";
				if (force || !(Time.unscaledTime - _lastStickerPreviewLogTime < 0.5f) || !string.Equals(text, _lastStickerPreviewLogKey, StringComparison.Ordinal))
				{
					_lastStickerPreviewLogTime = Time.unscaledTime;
					_lastStickerPreviewLogKey = text;
					DrawableSuitsDiagnostics.Info($"StickerPreviewUpdated: {text}; uv={uv}; pointerSource={_pointerSource}; cursor={_cursor}");
				}
			}
		}

		private void LogStickerSurfacePreviewUpdated(Texture2D texture, RaycastHit hit, MirrorPaintTarget mirrorTarget, Texture2D stampTexture, TextSurfaceStampStats primaryStats, TextSurfaceStampStats mirrorStats)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)texture == (Object)null) && !((Object)(object)stampTexture == (Object)null))
			{
				Vector2Int val = TexturePixel(texture, ((RaycastHit)(ref hit)).textureCoord);
				string text = $"surfacePreview|pixel={((Vector2Int)(ref val)).x},{((Vector2Int)(ref val)).y}|mirror={DescribeMirrorTarget(texture, mirrorTarget)}|shape={_stickerShape}|size={Mathf.RoundToInt(_stickerSize)}|rotation={Mathf.RoundToInt(_stickerRotation)}|color={ColorToHex(_brushColor)}|opacity={_brushOpacity:0.##}|stampTexture={((Texture)stampTexture).width}x{((Texture)stampTexture).height}|primaryWritten={primaryStats.WrittenPixels}|mirrorWritten={mirrorStats.WrittenPixels}|primaryCells={primaryStats.RasterizedCells}|mirrorCells={mirrorStats.RasterizedCells}|primarySeams={primaryStats.SeamSkippedCells}|mirrorSeams={mirrorStats.SeamSkippedCells}";
				if (!(Time.unscaledTime - _lastStickerPreviewLogTime < 0.5f) || !string.Equals(text, _lastStickerPreviewLogKey, StringComparison.Ordinal))
				{
					_lastStickerPreviewLogTime = Time.unscaledTime;
					_lastStickerPreviewLogKey = text;
					DrawableSuitsDiagnostics.Info($"StickerPreviewUpdated: {text}; hitPoint={((RaycastHit)(ref hit)).point}; hitNormal={((RaycastHit)(ref hit)).normal}; primarySamples={primaryStats.ProjectionSamples}; primaryHits={primaryStats.SurfaceHits}; primaryAlpha={primaryStats.AlphaPixels}; primarySkipped={primaryStats.SkippedPixels}; primaryOffSuit={primaryStats.OffSuitSamples}; primaryWorldSize={primaryStats.WorldWidth:0.###}x{primaryStats.WorldHeight:0.###}; mirrorSamples={mirrorStats.ProjectionSamples}; mirrorHits={mirrorStats.SurfaceHits}; mirrorAlpha={mirrorStats.AlphaPixels}; mirrorSkipped={mirrorStats.SkippedPixels}; mirrorOffSuit={mirrorStats.OffSuitSamples}; mirrorWorldSize={mirrorStats.WorldWidth:0.###}x{mirrorStats.WorldHeight:0.###}; pointerSource={_pointerSource}; cursor={_cursor}");
				}
			}
		}

		private void LogStickerSurfacePreviewSkipped(Texture2D texture, RaycastHit hit, MirrorPaintTarget mirrorTarget, Texture2D stampTexture, TextSurfaceStampStats primaryStats, TextSurfaceStampStats mirrorStats, string reason)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			Vector2Int val = (Vector2Int)(((Object)(object)texture != (Object)null) ? TexturePixel(texture, ((RaycastHit)(ref hit)).textureCoord) : new Vector2Int(-1, -1));
			string text = $"surfacePreviewSkipped|reason={reason}|pixel={((Vector2Int)(ref val)).x},{((Vector2Int)(ref val)).y}|mirror={DescribeMirrorTarget(texture, mirrorTarget)}|shape={_stickerShape}|stampTexture={((stampTexture != null) ? ((Texture)stampTexture).width : 0)}x{((stampTexture != null) ? ((Texture)stampTexture).height : 0)}|primarySkipped={primaryStats.SkippedPixels}|mirrorSkipped={mirrorStats.SkippedPixels}|primaryCells={primaryStats.RasterizedCells}|mirrorCells={mirrorStats.RasterizedCells}";
			if (!(Time.unscaledTime - _lastStickerPreviewLogTime < 0.75f) || !string.Equals(text, _lastStickerPreviewLogKey, StringComparison.Ordinal))
			{
				_lastStickerPreviewLogTime = Time.unscaledTime;
				_lastStickerPreviewLogKey = text;
				DrawableSuitsDiagnostics.Info($"StickerPreviewHidden: {text}; hitPoint={((RaycastHit)(ref hit)).point}; hitNormal={((RaycastHit)(ref hit)).normal}; primarySamples={primaryStats.ProjectionSamples}; primaryHits={primaryStats.SurfaceHits}; primaryOffSuit={primaryStats.OffSuitSamples}; primarySeams={primaryStats.SeamSkippedCells}; mirrorSamples={mirrorStats.ProjectionSamples}; mirrorHits={mirrorStats.SurfaceHits}; mirrorOffSuit={mirrorStats.OffSuitSamples}; mirrorSeams={mirrorStats.SeamSkippedCells}; pointerSource={_pointerSource}; cursor={_cursor}");
			}
		}

		private void LogPlacementPreviewHidden(string reason, bool force)
		{
			if (_placementPreviewTool == EditorTool.Text || _tool == EditorTool.Text)
			{
				LogTextPreviewHidden(reason, force);
			}
			else if (_placementPreviewTool == EditorTool.Sticker || _tool == EditorTool.Sticker)
			{
				LogStickerPreviewHidden(reason, force);
			}
			else
			{
				LogDecalPreviewHidden(reason, force);
			}
		}

		private void LogDecalPreviewHidden(string reason, bool force)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			string text = "hidden|reason=" + reason + "|mode=" + _previewMode + "|decal=" + CurrentDecalName();
			if (force || !(Time.unscaledTime - _lastDecalPreviewLogTime < 0.75f) || !string.Equals(text, _lastDecalPreviewLogKey, StringComparison.Ordinal))
			{
				_lastDecalPreviewLogTime = Time.unscaledTime;
				_lastDecalPreviewLogKey = text;
				DrawableSuitsDiagnostics.Info($"DecalPreviewHidden: {text}; pointerSource={_pointerSource}; cursor={_cursor}");
			}
		}

		private void LogTextPreviewHidden(string reason, bool force)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			string text = $"hidden|reason={reason}|mode={_previewMode}|textLength={NormalizeTextStampValue(_textStampValue).Length}";
			if (force || !(Time.unscaledTime - _lastTextPreviewLogTime < 0.75f) || !string.Equals(text, _lastTextPreviewLogKey, StringComparison.Ordinal))
			{
				_lastTextPreviewLogTime = Time.unscaledTime;
				_lastTextPreviewLogKey = text;
				DrawableSuitsDiagnostics.Info($"TextPreviewHidden: {text}; pointerSource={_pointerSource}; cursor={_cursor}");
			}
		}

		private void LogStickerPreviewHidden(string reason, bool force)
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			string text = $"hidden|reason={reason}|mode={_previewMode}|shape={_stickerShape}|size={Mathf.RoundToInt(_stickerSize)}|rotation={Mathf.RoundToInt(_stickerRotation)}";
			if (force || !(Time.unscaledTime - _lastStickerPreviewLogTime < 0.75f) || !string.Equals(text, _lastStickerPreviewLogKey, StringComparison.Ordinal))
			{
				_lastStickerPreviewLogTime = Time.unscaledTime;
				_lastStickerPreviewLogKey = text;
				DrawableSuitsDiagnostics.Info($"StickerPreviewHidden: {text}; pointerSource={_pointerSource}; cursor={_cursor}");
			}
		}

		private void LogDecalStampCommitted(string mode, Texture2D texture, Vector2 uv, MirrorPaintTarget mirrorTarget)
		{
			//IL_000a: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)texture == (Object)null))
			{
				int num = Mathf.RoundToInt(uv.x * (float)(((Texture)texture).width - 1));
				int num2 = Mathf.RoundToInt(uv.y * (float)(((Texture)texture).height - 1));
				object[] obj = new object[12]
				{
					mode,
					_pointerSource,
					uv,
					num,
					num2,
					DescribeMirrorTarget(texture, mirrorTarget),
					CurrentDecalName(),
					Mathf.RoundToInt(_decalSize),
					Mathf.RoundToInt(_decalRotation),
					_brushOpacity,
					null,
					null
				};
				Texture2D decalPreviewTexture = _decalPreviewTexture;
				obj[10] = ((decalPreviewTexture != null) ? ((Texture)decalPreviewTexture).width : 0);
				Texture2D decalPreviewTexture2 = _decalPreviewTexture;
				obj[11] = ((decalPreviewTexture2 != null) ? ((Texture)decalPreviewTexture2).height : 0);
				DrawableSuitsDiagnostics.Info(string.Format("DecalStampCommitted: mode={0}; pointerSource={1}; uv={2}; pixel={3},{4}; {5}; decal={6}; size={7}; rotation={8}; opacity={9:0.##}; previewTexture={10}x{11}", obj));
			}
		}

		private void LogDecalSurfaceStampCommitted(Texture2D texture, RaycastHit hit, MirrorPaintTarget mirrorTarget, Texture2D stampTexture, TextSurfaceStampStats primaryStats, TextSurfaceStampStats mirrorStats)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)texture == (Object)null))
			{
				Vector2Int val = TexturePixel(texture, ((RaycastHit)(ref hit)).textureCoord);
				DrawableSuitsDiagnostics.Info($"DecalSurfaceStampCommitted: mode=WorldThirdPerson; pointerSource={_pointerSource}; uv={((RaycastHit)(ref hit)).textureCoord}; pixel={((Vector2Int)(ref val)).x},{((Vector2Int)(ref val)).y}; {DescribeMirrorTarget(texture, mirrorTarget)}; decal={CurrentDecalName()}; size={Mathf.RoundToInt(_decalSize)}; rotation={Mathf.RoundToInt(_decalRotation)}; opacity={_brushOpacity:0.##}; stampTexture={((stampTexture != null) ? ((Texture)stampTexture).width : 0)}x{((stampTexture != null) ? ((Texture)stampTexture).height : 0)}; hitPoint={((RaycastHit)(ref hit)).point}; hitNormal={((RaycastHit)(ref hit)).normal}; primarySamples={primaryStats.ProjectionSamples}; primaryHits={primaryStats.SurfaceHits}; primaryCells={primaryStats.RasterizedCells}; primarySeams={primaryStats.SeamSkippedCells}; primaryWritten={primaryStats.WrittenPixels}; primarySkipped={primaryStats.SkippedPixels}; primaryOffSuit={primaryStats.OffSuitSamples}; primaryAlpha={primaryStats.AlphaPixels}; primaryWorldSize={primaryStats.WorldWidth:0.###}x{primaryStats.WorldHeight:0.###}; mirrorSamples={mirrorStats.ProjectionSamples}; mirrorHits={mirrorStats.SurfaceHits}; mirrorCells={mirrorStats.RasterizedCells}; mirrorSeams={mirrorStats.SeamSkippedCells}; mirrorWritten={mirrorStats.WrittenPixels}; mirrorSkipped={mirrorStats.SkippedPixels}; mirrorOffSuit={mirrorStats.OffSuitSamples}; mirrorAlpha={mirrorStats.AlphaPixels}; mirrorWorldSize={mirrorStats.WorldWidth:0.###}x{mirrorStats.WorldHeight:0.###}");
			}
		}

		private void LogDecalSurfaceStampSkipped(string mode, string reason, Texture2D texture, RaycastHit hit, MirrorPaintTarget mirrorTarget, Texture2D stampTexture, TextSurfaceStampStats primaryStats, TextSurfaceStampStats mirrorStats)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			Vector2Int val = (Vector2Int)(((Object)(object)texture != (Object)null) ? TexturePixel(texture, ((RaycastHit)(ref hit)).textureCoord) : new Vector2Int(-1, -1));
			string text = $"surfaceStampSkipped|mode={mode}|reason={reason}|pixel={((Vector2Int)(ref val)).x},{((Vector2Int)(ref val)).y}|mirror={DescribeMirrorTarget(texture, mirrorTarget)}|decal={CurrentDecalName()}|stampTexture={((stampTexture != null) ? ((Texture)stampTexture).width : 0)}x{((stampTexture != null) ? ((Texture)stampTexture).height : 0)}|primaryWritten={primaryStats.WrittenPixels}|mirrorWritten={mirrorStats.WrittenPixels}|primaryCells={primaryStats.RasterizedCells}|mirrorCells={mirrorStats.RasterizedCells}";
			if (!(Time.unscaledTime - _lastDecalPreviewLogTime < 0.75f) || !string.Equals(text, _lastDecalPreviewLogKey, StringComparison.Ordinal))
			{
				_lastDecalPreviewLogTime = Time.unscaledTime;
				_lastDecalPreviewLogKey = text;
				DrawableSuitsDiagnostics.Info($"DecalSurfaceStampSkipped: {text}; hitPoint={((RaycastHit)(ref hit)).point}; hitNormal={((RaycastHit)(ref hit)).normal}; primarySamples={primaryStats.ProjectionSamples}; primaryHits={primaryStats.SurfaceHits}; primarySkipped={primaryStats.SkippedPixels}; primaryOffSuit={primaryStats.OffSuitSamples}; primarySeams={primaryStats.SeamSkippedCells}; mirrorSamples={mirrorStats.ProjectionSamples}; mirrorHits={mirrorStats.SurfaceHits}; mirrorSkipped={mirrorStats.SkippedPixels}; mirrorOffSuit={mirrorStats.OffSuitSamples}; mirrorSeams={mirrorStats.SeamSkippedCells}; pointerSource={_pointerSource}; cursor={_cursor}");
			}
		}

		private void LogTextStampCommitted(string mode, Texture2D texture, Vector2 uv, MirrorPaintTarget mirrorTarget, Texture2D stampTexture)
		{
			//IL_000a: 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_004a: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)texture == (Object)null))
			{
				int num = Mathf.RoundToInt(uv.x * (float)(((Texture)texture).width - 1));
				int num2 = Mathf.RoundToInt(uv.y * (float)(((Texture)texture).height - 1));
				Vector2 val = (((Object)(object)stampTexture != (Object)null) ? GetPlacementStampPixelSize(stampTexture) : Vector2.zero);
				DrawableSuitsDiagnostics.Info($"TextStampCommitted: mode={mode}; pointerSource={_pointerSource}; uv={uv}; pixel={num},{num2}; {DescribeMirrorTarget(texture, mirrorTarget)}; textLength={NormalizeTextStampValue(_textStampValue).Length}; fontSize={Mathf.RoundToInt(_textSize)}; rotation={Mathf.RoundToInt(_textRotation)}; color={ColorToHex(_brushColor)}; opacity={_brushOpacity:0.##}; generatedTexture={((stampTexture != null) ? ((Texture)stampTexture).width : 0)}x{((stampTexture != null) ? ((Texture)stampTexture).height : 0)}; stampSize={Mathf.RoundToInt(val.x)}x{Mathf.RoundToInt(val.y)}");
			}
		}

		private void LogStickerStampCommitted(string mode, Texture2D texture, Vector2 uv, MirrorPaintTarget mirrorTarget, Texture2D stampTexture)
		{
			//IL_000a: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)texture == (Object)null))
			{
				int num = Mathf.RoundToInt(uv.x * (float)(((Texture)texture).width - 1));
				int num2 = Mathf.RoundToInt(uv.y * (float)(((Texture)texture).height - 1));
				object[] obj = new object[15]
				{
					mode,
					_pointerSource,
					uv,
					num,
					num2,
					DescribeMirrorTarget(texture, mirrorTarget),
					_stickerShape,
					Mathf.RoundToInt(_stickerSize),
					Mathf.RoundToInt(_stickerRotation),
					ColorToHex(_brushColor),
					_brushOpacity,
					(stampTexture != null) ? ((Texture)stampTexture).width : 0,
					(stampTexture != null) ? ((Texture)stampTexture).height : 0,
					null,
					null
				};
				Texture2D decalPreviewTexture = _decalPreviewTexture;
				obj[13] = ((decalPreviewTexture != null) ? ((Texture)decalPreviewTexture).width : 0);
				Texture2D decalPreviewTexture2 = _decalPreviewTexture;
				obj[14] = ((decalPreviewTexture2 != null) ? ((Texture)decalPreviewTexture2).height : 0);
				DrawableSuitsDiagnostics.Info(string.Format("StickerStampCommitted: mode={0}; pointerSource={1}; uv={2}; pixel={3},{4}; {5}; shape={6}; size={7}; rotation={8}; color={9}; opacity={10:0.##}; stampTexture={11}x{12}; previewTexture={13}x{14}", obj));
			}
		}

		private void LogTextSurfaceStampCommitted(Texture2D texture, RaycastHit hit, MirrorPaintTarget mirrorTarget, Texture2D stampTexture, TextSurfaceStampStats primaryStats, TextSurfaceStampStats mirrorStats)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)texture == (Object)null))
			{
				Vector2Int val = TexturePixel(texture, ((RaycastHit)(ref hit)).textureCoord);
				DrawableSuitsDiagnostics.Info($"TextSurfaceStampCommitted: mode=WorldThirdPerson; pointerSource={_pointerSource}; uv={((RaycastHit)(ref hit)).textureCoord}; pixel={((Vector2Int)(ref val)).x},{((Vector2Int)(ref val)).y}; {DescribeMirrorTarget(texture, mirrorTarget)}; textLength={NormalizeTextStampValue(_textStampValue).Length}; fontSize={Mathf.RoundToInt(_textSize)}; rotation={Mathf.RoundToInt(_textRotation)}; color={ColorToHex(_brushColor)}; opacity={_brushOpacity:0.##}; generatedTexture={((stampTexture != null) ? ((Texture)stampTexture).width : 0)}x{((stampTexture != null) ? ((Texture)stampTexture).height : 0)}; hitPoint={((RaycastHit)(ref hit)).point}; hitNormal={((RaycastHit)(ref hit)).normal}; primaryWritten={primaryStats.WrittenPixels}; primarySkipped={primaryStats.SkippedPixels}; primaryAlpha={primaryStats.AlphaPixels}; primaryWorldSize={primaryStats.WorldWidth:0.###}x{primaryStats.WorldHeight:0.###}; mirrorWritten={mirrorStats.WrittenPixels}; mirrorSkipped={mirrorStats.SkippedPixels}; mirrorAlpha={mirrorStats.AlphaPixels}; mirrorWorldSize={mirrorStats.WorldWidth:0.###}x{mirrorStats.WorldHeight:0.###}");
			}
		}

		private void LogStickerSurfaceStampCommitted(Texture2D texture, RaycastHit hit, MirrorPaintTarget mirrorTarget, Texture2D stampTexture, TextSurfaceStampStats primaryStats, TextSurfaceStampStats mirrorStats)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)texture == (Object)null))
			{
				Vector2Int val = TexturePixel(texture, ((RaycastHit)(ref hit)).textureCoord);
				DrawableSuitsDiagnostics.Info($"StickerStampCommitted: mode=WorldThirdPerson; pointerSource={_pointerSource}; uv={((RaycastHit)(ref hit)).textureCoord}; pixel={((Vector2Int)(ref val)).x},{((Vector2Int)(ref val)).y}; {DescribeMirrorTarget(texture, mirrorTarget)}; shape={_stickerShape}; size={Mathf.RoundToInt(_stickerSize)}; rotation={Mathf.RoundToInt(_stickerRotation)}; color={ColorToHex(_brushColor)}; opacity={_brushOpacity:0.##}; stampTexture={((stampTexture != null) ? ((Texture)stampTexture).width : 0)}x{((stampTexture != null) ? ((Texture)stampTexture).height : 0)}; hitPoint={((RaycastHit)(ref hit)).point}; hitNormal={((RaycastHit)(ref hit)).normal}; primarySamples={primaryStats.ProjectionSamples}; primaryHits={primaryStats.SurfaceHits}; primaryCells={primaryStats.RasterizedCells}; primarySeams={primaryStats.SeamSkippedCells}; primaryWritten={primaryStats.WrittenPixels}; primarySkipped={primaryStats.SkippedPixels}; primaryOffSuit={primaryStats.OffSuitSamples}; primaryAlpha={primaryStats.AlphaPixels}; primaryWorldSize={primaryStats.WorldWidth:0.###}x{primaryStats.WorldHeight:0.###}; mirrorSamples={mirrorStats.ProjectionSamples}; mirrorHits={mirrorStats.SurfaceHits}; mirrorCells={mirrorStats.RasterizedCells}; mirrorSeams={mirrorStats.SeamSkippedCells}; mirrorWritten={mirrorStats.WrittenPixels}; mirrorSkipped={mirrorStats.SkippedPixels}; mirrorOffSuit={mirrorStats.OffSuitSamples}; mirrorAlpha={mirrorStats.AlphaPixels}; mirrorWorldSize={mirrorStats.WorldWidth:0.###}x{mirrorStats.WorldHeight:0.###}");
			}
		}

		private void LogTextSurfaceStampSkipped(string mode, string reason, Texture2D texture, RaycastHit hit, MirrorPaintTarget mirrorTarget, Texture2D stampTexture, TextSurfaceStampStats primaryStats, TextSurfaceStampStats mirrorStats)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			Vector2Int val = (Vector2Int)(((Object)(object)texture != (Object)null) ? TexturePixel(texture, ((RaycastHit)(ref hit)).textureCoord) : new Vector2Int(-1, -1));
			string text = $"surfaceStampSkipped|mode={mode}|reason={reason}|pixel={((Vector2Int)(ref val)).x},{((Vector2Int)(ref val)).y}|mirror={DescribeMirrorTarget(texture, mirrorTarget)}|textLength={NormalizeTextStampValue(_textStampValue).Length}|stampTexture={((stampTexture != null) ? ((Texture)stampTexture).width : 0)}x{((stampTexture != null) ? ((Texture)stampTexture).height : 0)}|primaryWritten={primaryStats.WrittenPixels}|mirrorWritten={mirrorStats.WrittenPixels}";
			if (!(Time.unscaledTime - _lastTextPreviewLogTime < 0.75f) || !string.Equals(text, _lastTextPreviewLogKey, StringComparison.Ordinal))
			{
				_lastTextPreviewLogTime = Time.unscaledTime;
				_lastTextPreviewLogKey = text;
				DrawableSuitsDiagnostics.Info($"TextSurfaceStampSkipped: {text}; hitPoint={((RaycastHit)(ref hit)).point}; hitNormal={((RaycastHit)(ref hit)).normal}; primarySkipped={primaryStats.SkippedPixels}; mirrorSkipped={mirrorStats.SkippedPixels}; pointerSource={_pointerSource}; cursor={_cursor}");
			}
		}

		private void LogTextStampSkipped(string mode, string reason)
		{
			//IL_002e: 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)
			string text = $"skipped|mode={mode}|reason={reason}|textLength={NormalizeTextStampValue(_textStampValue).Length}|color={ColorToHex(_brushColor)}";
			if (!(Time.unscaledTime - _lastTextPreviewLogTime < 0.75f) || !string.Equals(text, _lastTextPreviewLogKey, StringComparison.Ordinal))
			{
				_lastTextPreviewLogTime = Time.unscaledTime;
				_lastTextPreviewLogKey = text;
				DrawableSuitsDiagnostics.Info($"TextStampSkipped: {text}; pointerSource={_pointerSource}; cursor={_cursor}");
			}
		}

		private void LogStickerSurfaceStampSkipped(string mode, string reason, Texture2D texture, RaycastHit hit, MirrorPaintTarget mirrorTarget, Texture2D stampTexture, TextSurfaceStampStats primaryStats, TextSurfaceStampStats mirrorStats)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_0126: 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_01e8: Unknown result type (might be due to invalid IL or missing references)
			Vector2Int val = (Vector2Int)(((Object)(object)texture != (Object)null) ? TexturePixel(texture, ((RaycastHit)(ref hit)).textureCoord) : new Vector2Int(-1, -1));
			string text = $"surfaceStampSkipped|mode={mode}|reason={reason}|pixel={((Vector2Int)(ref val)).x},{((Vector2Int)(ref val)).y}|mirror={DescribeMirrorTarget(texture, mirrorTarget)}|shape={_stickerShape}|stampTexture={((stampTexture != null) ? ((Texture)stampTexture).width : 0)}x{((stampTexture != null) ? ((Texture)stampTexture).height : 0)}|primaryWritten={primaryStats.WrittenPixels}|mirrorWritten={mirrorStats.WrittenPixels}|primaryCells={primaryStats.RasterizedCells}|mirrorCells={mirrorStats.RasterizedCells}";
			if (!(Time.unscaledTime - _lastStickerPreviewLogTime < 0.75f) || !string.Equals(text, _lastStickerPreviewLogKey, StringComparison.Ordinal))
			{
				_lastStickerPreviewLogTime = Time.unscaledTime;
				_lastStickerPreviewLogKey = text;
				DrawableSuitsDiagnostics.Info($"StickerStampSkipped: {text}; hitPoint={((RaycastHit)(ref hit)).point}; hitNormal={((RaycastHit)(ref hit)).normal}; primarySamples={primaryStats.ProjectionSamples}; primaryHits={primaryStats.SurfaceHits}; primarySkipped={primaryStats.SkippedPixels}; primaryOffSuit={primaryStats.OffSuitSamples}; primarySeams={primaryStats.SeamSkippedCells}; mirrorSamples={mirrorStats.ProjectionSamples}; mirrorHits={mirrorStats.SurfaceHits}; mirrorSkipped={mirrorStats.SkippedPixels}; mirrorOffSuit={mirrorStats.OffSuitSamples}; mirrorSeams={mirrorStats.SeamSkippedCells}; pointerSource={_pointerSource}; cursor={_cursor}");
			}
		}

		private void LogStickerStampSkipped(string mode, string reason)
		{
			//IL_004a: 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)
			string text = $"skipped|mode={mode}|reason={reason}|shape={_stickerShape}|size={Mathf.RoundToInt(_stickerSize)}|rotation={Mathf.RoundToInt(_stickerRotation)}|color={ColorToHex(_brushColor)}";
			if (!(Time.unscaledTime - _lastStickerPreviewLogTime < 0.75f) || !string.Equals(text, _lastStickerPreviewLogKey, StringComparison.Ordinal))
			{
				_lastStickerPreviewLogTime = Time.unscaledTime;
				_lastStickerPreviewLogKey = text;
				DrawableSuitsDiagnostics.Info($"StickerStampSkipped: {text}; pointerSource={_pointerSource}; cursor={_cursor}");
			}
		}

		private string CurrentDecalName()
		{
			if (_selectedDecalIndex < 0 || _selectedDecalIndex >= _decalFiles.Count)
			{
				return "none";
			}
			return Path.GetFileName(_decalFiles[_selectedDecalIndex]);
		}

		private static string MiddleEllipsize(string value, int maxChars)
		{
			if (string.IsNullOrWhiteSpace(value) || maxChars <= 0)
			{
				return string.Empty;
			}
			if (value.Length <= maxChars)
			{
				return value;
			}
			if (maxChars <= 3)
			{
				return value.Substring(0, maxChars);
			}
			int num = maxChars - "...".Length;
			int num2 = Mathf.Max(1, num / 2);
			int num3 = Mathf.Max(1, num - num2);
			if (num2 + num3 + "...".Length > maxChars)
			{
				num3 = Mathf.Max(1, maxChars - "...".Length - num2);
			}
			return value.Substring(0, num2) + "..." + value.Substring(value.Length - num3);
		}

		private MirrorPaintTarget ResolveWorldMirrorTarget(Texture2D texture, RaycastHit hit, bool allowStatus)
		{
			//IL_0066: 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_0070: 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_0074: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			MirrorPaintTarget mirrorPaintTarget = CreateMirrorTargetShell("WorldThirdPerson");
			if (!mirrorPaintTarget.Enabled || (Object)(object)texture == (Object)null || (Object)(object)_worldPaintProxyObject == (Object)null)
			{
				return mirrorPaintTarget;
			}
			if (!EnsureMirrorSurfaceMap(texture, "world mirror"))
			{
				mirrorPaintTarget.Reason = "mirror surface map unavailable";
				LogMirrorTarget(mirrorPaintTarget, texture, ((RaycastHit)(ref hit)).textureCoord, allowStatus);
				return mirrorPaintTarget;
			}
			Vector3 primaryLocalPoint = (mirrorPaintTarget.PrimaryLocalPoint = _worldPaintProxyObject.transform.InverseTransformPoint(((RaycastHit)(ref hit)).point));
			if (_mirrorSurfaceMap.TryMirrorFromLocalPoint(primaryLocalPoint, out var result))
			{
				mirrorPaintTarget.Available = true;
				mirrorPaintTarget.Uv = result.Uv;
				mirrorPaintTarget.ReflectedLocalPoint = result.ReflectedLocalPoint;
				mirrorPaintTarget.MirroredLocalPoint = result.LocalPoint;
				mirrorPaintTarget.MirroredLocalNormal = result.LocalNormal;
				mirrorPaintTarget.Distance = result.Distance;
				mirrorPaintTarget.TriangleIndex = result.TriangleIndex;
				mirrorPaintTarget.Reason = result.Reason;
			}
			else
			{
				mirrorPaintTarget.ReflectedLocalPoint = result.ReflectedLocalPoint;
				mirrorPaintTarget.MirroredLocalPoint = result.LocalPoint;
				mirrorPaintTarget.MirroredLocalNormal = result.LocalNormal;
				mirrorPaintTarget.Distance = result.Distance;
				mirrorPaintTarget.TriangleIndex = result.TriangleIndex;
				mirrorPaintTarget.Reason = result.Reason;
			}
			LogMirrorTarget(mirrorPaintTarget, texture, ((RaycastHit)(ref hit)).textureCoord, allowStatus);
			return mirrorPaintTarget;
		}

		private MirrorPaintTarget ResolveUvMirrorTarget(Texture2D texture, Vector2 uv, bool allowStatus, string mode = "TextureFallback")
		{
			//IL_0048: 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_0074: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			MirrorPaintTarget mirrorPaintTarget = CreateMirrorTargetShell(mode);
			if (!mirrorPaintTarget.Enabled || (Object)(object)texture == (Object)null)
			{
				return mirrorPaintTarget;
			}
			if (!EnsureMirrorSurfaceMap(texture, "uv fallback mirror"))
			{
				mirrorPaintTarget.Reason = "mirror surface map unavailable";
				LogMirrorTarget(mirrorPaintTarget, texture, uv, allowStatus);
				return mirrorPaintTarget;
			}
			if (!_mirrorSurfaceMap.TryLocalPointFromUv(uv, out var localPoint, out var triangleIndex, out var reason))
			{
				mirrorPaintTarget.Reason = reason;
				mirrorPaintTarget.TriangleIndex = triangleIndex;
				LogMirrorTarget(mirrorPaintTarget, texture, uv, allowStatus);
				return mirrorPaintTarget;
			}
			mirrorPaintTarget.PrimaryLocalPoint = localPoint;
			if (_mirrorSurfaceMap.TryMirrorFromLocalPoint(localPoint, out var result))
			{
				mirrorPaintTarget.Available = true;
				mirrorPaintTarget.Uv = result.Uv;
				mirrorPaintTarget.ReflectedLocalPoint = result.ReflectedLocalPoint;
				mirrorPaintTarget.MirroredLocalPoint = result.LocalPoint;
				mirrorPaintTarget.MirroredLocalNormal = result.LocalNormal;
				mirrorPaintTarget.Distance = result.Distance;
				mirrorPaintTarget.TriangleIndex = result.TriangleIndex;
				mirrorPaintTarget.Reason = reason + "; " + result.Reason;
			}
			else
			{
				mirrorPaintTarget.ReflectedLocalPoint = result.ReflectedLocalPoint;
				mirrorPaintTarget.MirroredLocalPoint = result.LocalPoint;
				mirrorPaintTarget.MirroredLocalNormal = result.LocalNormal;
				mirrorPaintTarget.Distance = result.Distance;
				mirrorPaintTarget.TriangleIndex = result.TriangleIndex;
				mirrorPaintTarget.Reason = result.Reason;
			}
			LogMirrorTarget(mirrorPaintTarget, texture, uv, allowStatus);
			return mirrorPaintTarget;
		}

		private MirrorPaintTarget CreateMirrorTargetShell(string mode)
		{
			return new MirrorPaintTarget
			{
				Enabled = _mirrorEnabled,
				Available = false,
				Mode = mode,
				Reason = (_mirrorEnabled ? "not resolved" : "disabled")
			};
		}

		private bool EnsureMirrorSurfaceMap(Texture2D texture, string context)
		{
			//IL_0066: 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_0077: Expected O, but got Unknown
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			if (!_mirrorEnabled)
			{
				return false;
			}
			SkinnedMeshRenderer val = _worldSourceRenderer ?? FindBestSuitRenderer(StartOfRound.Instance?.localPlayerController);
			Mesh val2 = (((Object)(object)_worldPaintMesh != (Object)null && _worldPaintMesh.vertexCount > 0) ? _worldPaintMesh : null);
			Mesh val3 = null;
			try
			{
				if ((Object)(object)val2 == (Object)null && (Object)(object)val != (Object)null)
				{
					val3 = new Mesh
					{
						name = "DrawableSuitsMirrorSurfaceBake"
					};
					bool enabled = ((Renderer)val).enabled;
					try
					{
						((Renderer)val).enabled = true;
						val.BakeMesh(val3, true);
					}
					finally
					{
						((Renderer)val).enabled = enabled;
					}
					if (val3.vertexCount > 0)
					{
						val3.RecalculateBounds();
						val2 = val3;
					}
				}
				if ((Object)(object)val2 == (Object)null || val2.vertexCount == 0)
				{
					InvalidateMirrorSurfaceMap("no mesh");
					return false;
				}
				string text = string.Format("{0}|{1}|v={2}|sub={3}|bounds={4}|texture={5}x{6}", _selectedSuitId, ((val != null) ? ((Object)val).name : null) ?? "unknown", val2.vertexCount, val2.subMeshCount, val2.bounds, (texture != null) ? ((Texture)texture).width : 0, (texture != null) ? ((Texture)texture).height : 0);
				if (_mirrorSurfaceMap != null && string.Equals(_mirrorSurfaceMapKey, text, StringComparison.Ordinal))
				{
					return true;
				}
				_mirrorSurfaceMap = MirrorSurfaceMap.Build(val2, text);
				_mirrorSurfaceMapKey = _mirrorSurfaceMap?.Key ?? string.Empty;
				if (_mirrorSurfaceMap == null)
				{
					object[] obj = new object[5] { context, text, val2.vertexCount, val2.subMeshCount, null };
					Vector2[] uv = val2.uv;
					obj[4] = ((uv != null) ? uv.Length : 0);
					DrawableSuitsDiagnostics.Warn(string.Format("MirrorSurfaceMap build failed. context={0}; key={1}; meshVertices={2}; subMeshes={3}; uvCount={4}", obj));
					return false;
				}
				DrawableSuitsDiagnostics.Info($"MirrorSurfaceMap built. context={context}; key={text}; triangles={_mirrorSurfaceMap.TriangleCount}; bounds={_mirrorSurfaceMap.Bounds}; mirrorPlaneX={_mirrorSurfaceMap.MirrorPlaneX:0.###}");
				return true;
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception("MirrorSurfaceMap build failed. context=" + context, exception);
				InvalidateMirrorSurfaceMap("exception");
				return false;
			}
			finally
			{
				if ((Object)(object)val3 != (Object)null)
				{
					Object.Destroy((Object)(object)val3);
				}
			}
		}

		private void InvalidateMirrorSurfaceMap(string reason)
		{
			if (_mirrorSurfaceMap != null || !string.IsNullOrEmpty(_mirrorSurfaceMapKey))
			{
				DrawableSuitsDiagnostics.Info("MirrorSurfaceMap invalidated. reason=" + reason + "; previousKey=" + _mirrorSurfaceMapKey);
			}
			_mirrorSurfaceMap = null;
			_mirrorSurfaceMapKey = string.Empty;
		}

		private unsafe void LogMirrorTarget(MirrorPaintTarget target, Texture2D texture, Vector2 primaryUv, bool allowStatus)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_001b: 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_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			if (!target.Enabled)
			{
				return;
			}
			Vector2Int val = TexturePixel(texture, primaryUv);
			Vector2Int val2 = (Vector2Int)(target.Available ? TexturePixel(texture, target.Uv) : new Vector2Int(-1, -1));
			string text = $"mode={target.Mode}|available={target.Available}|primary={((Vector2Int)(ref val)).x},{((Vector2Int)(ref val)).y}|mirrored={((Vector2Int)(ref val2)).x},{((Vector2Int)(ref val2)).y}|tri={target.TriangleIndex}|reason={target.Reason}";
			if (!(Time.unscaledTime - _lastMirrorDiagnosticsTime < 0.75f) || !string.Equals(text, _lastMirrorDiagnosticsKey, StringComparison.Ordinal))
			{
				_lastMirrorDiagnosticsTime = Time.unscaledTime;
				_lastMirrorDiagnosticsKey = text;
				DrawableSuitsDiagnostics.Info(string.Format("MirrorSurfaceTarget: {0}; primaryUv={1}; mirroredUv={2}; primaryLocal={3}; reflectedLocal={4}; mirrorLocal={5}; distance={6:0.###}; mapKey={7}", text, primaryUv, target.Available ? ((object)(*(Vector2*)(&target.Uv))/*cast due to .constrained prefix*/).ToString() : "none", target.PrimaryLocalPoint, target.ReflectedLocalPoint, target.MirroredLocalPoint, target.Distance, _mirrorSurfaceMapKey));
				if (allowStatus && !target.Available)
				{
					SetStatus("Mirror target not found; applied primary only.", warn: false);
				}
			}
		}

		private static Vector2Int TexturePixel(Texture2D texture, Vector2 uv)
		{
			//IL_0011: 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_0045: 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)
			if ((Object)(object)texture == (Object)null)
			{
				return new Vector2Int(-1, -1);
			}
			return new Vector2Int(Mathf.RoundToInt(Mathf.Clamp01(uv.x) * (float)(((Texture)texture).width - 1)), Mathf.RoundToInt(Mathf.Clamp01(uv.y) * (float)(((Texture)texture).height - 1)));
		}

		private static bool ShouldApplyMirror(Texture2D texture, Vector2 primaryUv, MirrorPaintTarget mirrorTarget)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if ((Object)(object)texture == (Object)null || !mirrorTarget.Enabled || !mirrorTarget.Available)
			{
				return false;
			}
			Vector2Int val = TexturePixel(texture, primaryUv);
			Vector2Int val2 = TexturePixel(texture, mirrorTarget.Uv);
			if (((Vector2Int)(ref val)).x == ((Vector2Int)(ref val2)).x)
			{
				return ((Vector2Int)(ref val)).y != ((Vector2Int)(ref val2)).y;
			}
			return true;
		}

		private string DescribeMirrorTarget(Texture2D texture, MirrorPaintTarget mirrorTarget)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (!mirrorTarget.Enabled)
			{
				return "mirrorEnabled=False";
			}
			if (!mirrorTarget.Available)
			{
				return "mirrorEnabled=True; mirrorMode=SurfaceMap; mirrorAvailable=False; reason=" + mirrorTarget.Reason;
			}
			Vector2Int val = TexturePixel(texture, mirrorTarget.Uv);
			return $"mirrorEnabled=True; mirrorMode=SurfaceMap; mirroredUv={mirrorTarget.Uv}; mirroredPixel={((Vector2Int)(ref val)).x},{((Vector2Int)(ref val)).y}; mirrorDistance={mirrorTarget.Distance:0.###}; mirrorTriangle={mirrorTarget.TriangleIndex}; mirrorReason={mirrorTarget.Reason}";
		}

		private void HandleControllerCursor()
		{
			//IL_003d: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			_mousePositionAvailable = DrawableSuitsInput.TryGetMousePosition(out _lastMousePosition);
			bool num = Time.unscaledTime >= _ignoreMouseInputUntilTime && DrawableSuitsInput.WasMouseUsedThisFrame();
			Gamepad current = Gamepad.current;
			_lastGamepadStick = ((current != null) ? ((InputControl<Vector2>)(object)current.leftStick).ReadValue() : Vector2.zero);
			bool flag = current != null && ((Vector2)(ref _lastGamepadStick)).sqrMagnitude > 0.0324f;
			if (flag && !_gamepadClickArmed)
			{
				_gamepadClickArmed = true;
				DrawableSuitsDiagnostics.Info($"Controller virtual cursor armed after stick movement. stick={_lastGamepadStick}; cursor={_cursor}");
			}
			bool flag2 = current != null && (flag || ((InputControl<float>)(object)current.rightTrigger).ReadValue() > 0.2f || current.leftShoulder.isPressed || current.rightShoulder.isPressed);
			if (num)
			{
				_usingGamepadPointer = false;
			}
			else if (flag2)
			{
				_usingGamepadPointer = true;
			}
			else if (current == null)
			{
				_usingGamepadPointer = false;
			}
			if (_usingGamepadPointer && current != null)
			{
				_pointerSource = "Gamepad";
				Vector2 val = _lastGamepadStick * DrawableSuitsPlugin.ModConfig.ControllerCursorSpeed.Value * Time.unscaledDeltaTime;
				_cursor.x = Mathf.Clamp(_cursor.x + val.x, 0f, (float)Screen.width);
				_cursor.y = Mathf.Clamp(_cursor.y + val.y, 0f, (float)Screen.height);
			}
			else
			{
				_pointerSource = "Mouse";
				if (_mousePositionAvailable)
				{
					_cursor = _lastMousePosition;
				}
			}
		}

		private void HandleVirtualCursorClick()
		{
			//IL_0067: 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_00da: 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)
			Gamepad current = Gamepad.current;
			if (current == null || !_editorUiInputActive || (Object)(object)_editorCanvasObject == (Object)null)
			{
				_virtualPointerDown = false;
				_virtualPointerPressTarget = null;
				_virtualPointerSlider = null;
				_virtualPointerColorPicker = null;
				_virtualPointerButton = null;
				_virtualPointerInput = null;
				return;
			}
			ButtonControl buttonSouth = current.buttonSouth;
			if (buttonSouth.wasPressedThisFrame)
			{
				if (!_gamepadClickArmed)
				{
					DrawableSuitsDiagnostics.Info($"Virtual cursor A press ignored before controller cursor was armed. Move the left stick once before clicking. cursor={_cursor}; rawHits=[{DescribeRaycastHits(RaycastEditorUi(_cursor))}]");
					_virtualPointerDown = false;
					_virtualPointerPressTarget = null;
					_virtualPointerSlider = null;
					_virtualPointerColorPicker = null;
					_virtualPointerButton = null;
					_virtualPointerInput = null;
					return;
				}
				BeginVirtualPointerPress();
			}
			if (buttonSouth.isPressed && (Object)(object)_virtualPointerSlider != (Object)null)
			{
				_virtualPointerSlider.SetValueFromScreenPosition(_cursor, null, notify: true);
			}
			if (buttonSouth.isPressed && (Object)(object)_virtualPointerColorPicker != (Object)null)
			{
				_virtualPointerColorPicker.SetValueFromScreenPosition(_cursor, null, notify: true);
			}
			if (buttonSouth.wasReleasedThisFrame)
			{
				EndVirtualPointerPress();
			}
		}

		private void BeginVirtualPointerPress()
		{
			//IL_002c: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			_virtualPointerDown = true;
			_virtualPointerPressTarget = null;
			_virtualPointerSlider = null;
			_virtualPointerColorPicker = null;
			_virtualPointerButton = null;
			_virtualPointerInput = null;
			List<RaycastResult> hits = RaycastEditorUi(_cursor);
			string text = DescribeRaycastHits(hits);
			if (!TryResolveVirtualCursorTarget(hits, out var target, out var button, out var input, out var slider, out var colorPicker))
			{
				DrawableSuitsDiagnostics.Info($"Virtual cursor A press hit no actionable UI target. cursor={_cursor}; rawHits=[{text}]");
			}
			else if ((Object)(object)slider != (Object)null)
			{
				_virtualPointerSlider = slider;
				_virtualPointerPressTarget = ((Component)slider).gameObject;
				EventSystem current = EventSystem.current;
				if (current != null)
				{
					current.SetSelectedGameObject(((Component)slider).gameObject);
				}
				slider.SetValueFromScreenPosition(_cursor, null, notify: true);
				DrawableSuitsDiagnostics.Info($"Virtual cursor A press captured slider={((Object)slider).name}; resolved={((Object)target).name}; cursor={_cursor}; rawHits=[{text}]");
			}
			else if ((Object)(object)colorPicker != (Object)null)
			{
				_virtualPointerColorPicker = colorPicker;
				_virtualPointerPressTarget = ((Component)colorPicker).gameObject;
				EventSystem current2 = EventSystem.current;
				if (current2 != null)
				{
					current2.SetSelectedGameObject(((Component)colorPicker).gameObject);
				}
				colorPicker.SetValueFromScreenPosition(_cursor, null, notify: true);
				DrawableSuitsDiagnostics.Info($"Virtual cursor A press captured colorPicker={((Object)colorPicker).name}; resolved={((Object)target).name}; cursor={_cursor}; rawHits=[{text}]");
			}
			else if ((Object)(object)input != (Object)null)
			{
				_virtualPointerInput = input;
				_virtualPointerPressTarget = ((Component)input).gameObject;
				EventSystem current3 = EventSystem.current;
				if (current3 != null)
				{
					current3.SetSelectedGameObject(((Component)input).gameObject);
				}
				input.ActivateInputField();
				DrawableSuitsDiagnostics.Info($"Virtual cursor A press focused input={((Object)input).name}; resolved={((Object)target).name}; cursor={_cursor}; rawHits=[{text}]");
			}
			else if ((Object)(object)button != (Object)null)
			{
				_virtualPointerButton = button;
				_virtualPointerPressTarget = ((Component)button).gameObject;
				DrawableSuitsDiagnostics.Info($"Virtual cursor A press captured button={((Object)button).name}; resolved={((Object)target).name}; cursor={_cursor}; rawHits=[{text}]");
			}
		}

		private void EndVirtualPointerPress()
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			if (!_virtualPointerDown)
			{
				return;
			}
			_virtualPointerDown = false;
			GameObject virtualPointerPressTarget = _virtualPointerPressTarget;
			Button virtualPointerButton = _virtualPointerButton;
			DrawableSliderControl virtualPointerSlider = _virtualPointerSlider;
			DrawableColorPickerControl virtualPointerColorPicker = _virtualPointerColorPicker;
			_virtualPointerPressTarget = null;
			_virtualPointerSlider = null;
			_virtualPointerColorPicker = null;
			_virtualPointerButton = null;
			_virtualPointerInput = null;
			if ((Object)(object)virtualPointerPressTarget == (Object)null)
			{
				return;
			}
			virtualPointerColorPicker?.EndVirtualDrag();
			List<RaycastResult> hits = RaycastEditorUi(_cursor);
			TryResolveVirtualCursorTarget(hits, out var target, out var button, out var _, out var _, out var _);
			if ((Object)(object)virtualPointerButton != (Object)null && (Object)(object)button == (Object)(object)virtualPointerButton && ((UIBehaviour)virtualPointerButton).IsActive() && ((Selectable)virtualPointerButton).IsInteractable())
			{
				((UnityEvent)virtualPointerButton.onClick).Invoke();
				ClearSelectedNormalButton();
			}
			else if ((Object)(object)virtualPointerSlider != (Object)null || (Object)(object)virtualPointerColorPicker != (Object)null)
			{
				EventSystem current = EventSystem.current;
				if (current != null)
				{
					current.SetSelectedGameObject((GameObject)null);
				}
			}
			DrawableSuitsDiagnostics.Info(string.Format("Virtual cursor A release target={0}; releaseTarget={1}; pressButton={2}; releaseButton={3}; cursor={4}; rawHits=[{5}]", ((Object)virtualPointerPressTarget).name, ((target != null) ? ((Object)target).name : null) ?? "null", ((virtualPointerButton != null) ? ((Object)virtualPointerButton).name : null) ?? "null", ((button != null) ? ((Object)button).name : null) ?? "null", _cursor, DescribeRaycastHits(hits)));
		}

		private PointerEventData CreateVirtualPointerEventData()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			return new PointerEventData(EventSystem.current ?? _editorEventSystem)
			{
				pointerId = -1003,
				position = _cursor,
				pressPosition = _cursor,
				button = (InputButton)0
			};
		}

		private GameObject TopClickableAtCursor()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			if (!TryResolveVirtualCursorTarget(RaycastEditorUi(_cursor), out var target, out var _, out var _, out var _, out var _))
			{
				return null;
			}
			return target;
		}

		private static bool TryResolveVirtualCursorTarget(List<RaycastResult> hits, out GameObject target, out Button button, out InputField input, out DrawableSliderControl slider, out DrawableColorPickerControl colorPicker)
		{
			//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_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			target = null;
			button = null;
			input = null;
			slider = null;
			colorPicker = null;
			if (hits == null)
			{
				return false;
			}
			RaycastResult val;
			for (int i = 0; i < hits.Count; i++)
			{
				val = hits[i];
				GameObject gameObject = ((RaycastResult)(ref val)).gameObject;
				if (!((Object)(object)gameObject == (Object)null) && gameObject.activeInHierarchy)
				{
					slider = gameObject.GetComponentInParent<DrawableSliderControl>();
					if ((Object)(object)slider != (Object)null && ((UIBehaviour)slider).IsActive() && ((Selectable)slider).IsInteractable())
					{
						target = ((Component)slider).gameObject;
						return true;
					}
					input = gameObject.GetComponentInParent<InputField>();
					if ((Object)(object)input != (Object)null && ((UIBehaviour)input).IsActive() && ((Selectable)input).IsInteractable())
					{
						target = ((Component)input).gameObject;
						return true;
					}
					button = gameObject.GetComponentInParent<Button>();
					if ((Object)(object)button != (Object)null && ((UIBehaviour)button).IsActive() && ((Selectable)button).IsInteractable())
					{
						target = ((Component)button).gameObject;
						return true;
					}
				}
			}
			for (int j = 0; j < hits.Count; j++)
			{
				val = hits[j];
				GameObject gameObject2 = ((RaycastResult)(ref val)).gameObject;
				if (!((Object)(object)gameObject2 == (Object)null) && gameObject2.activeInHierarchy)
				{
					colorPicker = gameObject2.GetComponentInParent<DrawableColorPickerControl>();
					if ((Object)(object)colorPicker != (Object)null && ((UIBehaviour)colorPicker).IsActive() && ((Selectable)colorPicker).IsInteractable())
					{
						target = ((Component)colorPicker).gameObject;
						return true;
					}
				}
			}
			return false;
		}

		private static string DescribeRaycastHits(List<RaycastResult> hits)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (hits == null || hits.Count == 0)
			{
				return "none";
			}
			int num = Mathf.Min(8, hits.Count);
			string[] array = new string[num];
			for (int i = 0; i < num; i++)
			{
				int num2 = i;
				RaycastResult val = hits[i];
				object obj;
				if (!((Object)(object)((RaycastResult)(ref val)).gameObject != (Object)null))
				{
					obj = "null";
				}
				else
				{
					val = hits[i];
					obj = ((Object)((RaycastResult)(ref val)).gameObject).name;
				}
				array[num2] = (string)obj;
			}
			return string.Join(", ", array);
		}

		private List<RaycastResult> RaycastEditorUi(Vector2 screenPosition)
		{
			//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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			List<RaycastResult> list = new List<RaycastResult>();
			GraphicRaycaster val = (((Object)(object)_editorCanvasObject != (Object)null) ? _editorCanvasObject.GetComponent<GraphicRaycaster>() : null);
			EventSystem val2 = EventSystem.current ?? _editorEventSystem;
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
			{
				return list;
			}
			PointerEventData val3 = new PointerEventData(val2)
			{
				position = screenPosition
			};
			((BaseRaycaster)val).Raycast(val3, list);
			return list;
		}

		private void HandleEditorShortcuts()
		{
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			if (_bootstrapShell)
			{
				return;
			}
			UpdateLabels();
			if (IsEditorModalOpen())
			{
				return;
			}
			bool flag = CanHandlePlacementRotationShortcuts();
			bool flag2 = CanHandleUvPanelRotationShortcuts();
			Gamepad current = Gamepad.current;
			if (current != null)
			{
				if (current.buttonNorth.wasPressedThisFrame)
				{
					CycleTool();
				}
				if (current.buttonWest.wasPressedThisFrame)
				{
					Undo();
				}
				if (current.startButton.wasPressedThisFrame)
				{
					SaveDesign();
				}
				if (flag2)
				{
					if (current.leftShoulder.wasPressedThisFrame)
					{
						RotateUvPanel(-1, "GamepadLeftShoulder");
					}
					if (current.rightShoulder.wasPressedThisFrame)
					{
						RotateUvPanel(1, "GamepadRightShoulder");
					}
				}
				if (flag)
				{
					if (current.dpad.left.wasPressedThisFrame)
					{
						ApplyPlacementRotationShortcut(-5f, "GamepadDpadLeft");
					}
					if (current.dpad.right.wasPressedThisFrame)
					{
						ApplyPlacementRotationShortcut(5f, "GamepadDpadRight");
					}
				}
			}
			if (flag2)
			{
				if (DrawableSuitsInput.WasKeyPressed((Key)11))
				{
					RotateUvPanel(-1, "KeyboardLeftBracket");
				}
				if (DrawableSuitsInput.WasKeyPressed((Key)12))
				{
					RotateUvPanel(1, "KeyboardRightBracket");
				}
			}
			if (flag)
			{
				if (DrawableSuitsInput.WasKeyPressed((Key)7))
				{
					ApplyPlacementRotationShortcut(-5f, "KeyboardComma");
				}
				if (DrawableSuitsInput.WasKeyPressed((Key)8))
				{
					ApplyPlacementRotationShortcut(5f, "KeyboardPeriod");
				}
			}
			if (IsWorldThirdPersonMode)
			{
				bool num = IsCursorOverPreviewViewport();
				float num2 = DrawableSuitsInput.MouseScrollY();
				if (num)
				{
					HandleUvPanelViewInput(num2, current, "TexturePanel");
					return;
				}
				if (current != null)
				{
					Vector2 val = ((InputControl<Vector2>)(object)current.rightStick).ReadValue();
					if (((Vector2)(ref val)).sqrMagnitude > 0.01f)
					{
						_worldCameraYaw += val.x * 140f * Time.unscaledDeltaTime;
						_worldCameraPitch -= val.y * 90f * Time.unscaledDeltaTime;
					}
					Vector2 val2 = ((InputControl<Vector2>)(object)current.dpad).ReadValue();
					if (Mathf.Abs(val2.y) > 0.35f)
					{
						_worldCameraDistance = Mathf.Clamp(_worldCameraDistance - val2.y * Time.unscaledDeltaTime * 2f, 1.5f, 8f);
					}
				}
				if (!IsCursorOverEditorPanel() && DrawableSuitsInput.IsRightMousePressed())
				{
					_worldCameraYaw += DrawableSuitsInput.MouseDeltaX() * 3f;
					_worldCameraPitch -= DrawableSuitsInput.MouseDeltaY() * 2f;
				}
				if (IsCursorOverEditorPanel() || !(Mathf.Abs(num2) > 0.01f))
				{
					return;
				}
				if (DrawableSuitsInput.IsKeyPressed((Key)55) || DrawableSuitsInput.IsKeyPressed((Key)56))
				{
					_brushSize = Mathf.Clamp(_brushSize + num2 * 2f, 1f, 96f);
					if ((Object)(object)_brushSizeSlider != (Object)null)
					{
						_brushSizeSlider.SetValue(_brushSize, notify: false);
					}
				}
				else
				{
					_worldCameraDistance = Mathf.Clamp(_worldCameraDistance - num2 * 0.25f, 1.5f, 8f);
				}
			}
			else if (IsCursorOverPreviewViewport())
			{
				HandleUvPanelViewInput(DrawableSuitsInput.MouseScrollY(), current, "TextureFallback");
			}
		}

		private void HandlePaintingInput()
		{
			if (_bootstrapShell)
			{
				_strokeActive = false;
				_decalStampArmed = true;
			}
			else if (IsEditorModalOpen())
			{
				_strokeActive = false;
				_decalStampArmed = true;
				_suppressPaintInputUntilRelease = false;
				_suppressDecalPreviewUntilRelease = false;
				HideDecalPlacementPreview("editor modal open", forceLog: false);
			}
			else if (!_canPaint)
			{
				_strokeActive = false;
				_decalStampArmed = true;
			}
			else if (IsWorldThirdPersonMode && IsCursorOverPreviewViewport())
			{
				HandleTexturePanelPaintingInput("TexturePanel");
			}
			else if (IsWorldThirdPersonMode)
			{
				HandleWorldPaintingInput();
			}
			else
			{
				HandleTexturePanelPaintingInput("TextureFallback");
			}
		}

		private void HandleTexturePanelPaintingInput(string mode)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: 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_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			bool num = DrawableSuitsInput.IsLeftMousePressed();
			Gamepad current = Gamepad.current;
			bool flag = current != null && ((InputControl<float>)(object)current.rightTrigger).ReadValue() > 0.55f;
			if (!(num || flag))
			{
				_strokeActive = false;
				_brushStrokeSeed = 1;
				_decalStampArmed = true;
				_suppressPaintInputUntilRelease = false;
				_suppressDecalPreviewUntilRelease = false;
			}
			else
			{
				if (_suppressPaintInputUntilRelease)
				{
					return;
				}
				Texture2D editableTexture = DrawableSuitsPlugin.Registry.GetEditableTexture(_selectedSuitId);
				Vector2 uv;
				bool flag2 = TryGetTexturePreviewUv(_cursor, out uv);
				bool flag3 = IsCursorOverPreviewViewport() && flag2;
				if (_tool == EditorTool.Eyedropper)
				{
					HandleEyedropperInput(editableTexture, flag3, uv, mode);
					return;
				}
				MirrorPaintTarget mirrorTarget = ((flag3 && (Object)(object)editableTexture != (Object)null) ? ResolveUvMirrorTarget(editableTexture, uv, allowStatus: false, mode) : CreateMirrorTargetShell(mode));
				LogPaintAttemptIfNeeded(mode + " paint input", flag3, flag2, uv, editableTexture, mirrorTarget, !_strokeActive);
				if (_tool == EditorTool.FillBucket)
				{
					HandleFillBucketInput(editableTexture, flag3, uv, mirrorTarget, mode);
				}
				else if (IsPlacementTool(_tool))
				{
					HandleSinglePlacementStampInput(editableTexture, flag3, uv, mirrorTarget, mode);
				}
				else if (!flag3 || (Object)(object)editableTexture == (Object)null)
				{
					_strokeActive = false;
				}
				else if (_tool == EditorTool.Decal && (Object)(object)_loadedDecal == (Object)null)
				{
					WarnMissingDecal("paint input");
					_tool = EditorTool.Paint;
					UpdateToolButtons();
					UpdateBrushIndicator();
					_strokeActive = false;
				}
				else
				{
					if (!_strokeActive)
					{
						BeginBrushStroke();
					}
					PaintAtCursor(editableTexture, uv, mirrorTarget);
				}
			}
		}

		private void HandleWorldPaintingInput()
		{
			//IL_007b: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: 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_00ec: 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_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			bool num = !IsCursorOverEditorPanel() && DrawableSuitsInput.IsLeftMousePressed();
			Gamepad current = Gamepad.current;
			bool flag = current != null && ((InputControl<float>)(object)current.rightTrigger).ReadValue() > 0.55f;
			if (!(num || flag))
			{
				_strokeActive = false;
				_brushStrokeSeed = 1;
				_decalStampArmed = true;
				_suppressPaintInputUntilRelease = false;
				_suppressDecalPreviewUntilRelease = false;
			}
			else
			{
				if (_suppressPaintInputUntilRelease)
				{
					return;
				}
				Texture2D editableTexture = DrawableSuitsPlugin.Registry.GetEditableTexture(_selectedSuitId);
				bool num2 = !IsCursorOverEditorPanel();
				RaycastHit hit = default(RaycastHit);
				bool flag2 = num2 && TryGetWorldPaintHit(out hit);
				Vector2 uv = (Vector2)(flag2 ? ((RaycastHit)(ref hit)).textureCoord : default(Vector2));
				if (_tool == EditorTool.Eyedropper)
				{
					HandleEyedropperInput(editableTexture, flag2, uv, "WorldThirdPerson");
					return;
				}
				MirrorPaintTarget mirrorTarget = ((flag2 && (Object)(object)editableTexture != (Object)null) ? ResolveWorldMirrorTarget(editableTexture, hit, allowStatus: false) : CreateMirrorTargetShell("WorldThirdPerson"));
				LogPaintAttemptIfNeeded("world paint input", flag2, flag2, uv, editableTexture, mirrorTarget, !_strokeActive);
				if (_tool == EditorTool.FillBucket)
				{
					HandleFillBucketInput(editableTexture, flag2, uv, mirrorTarget, "WorldThirdPerson");
					return;
				}
				if (IsPlacementTool(_tool))
				{
					if (_tool == EditorTool.Text)
					{
						HandleWorldTextStampInput(editableTexture, flag2, hit, mirrorTarget);
					}
					else if (_tool == EditorTool.Sticker)
					{
						HandleWorldStickerStampInput(editableTexture, flag2, hit, mirrorTarget);
					}
					else
					{
						HandleWorldDecalStampInput(editableTexture, flag2, hit, mirrorTarget);
					}
					return;
				}
				if (!flag2 || (Object)(object)editableTexture == (Object)null)
				{
					if (!_statusMessage.StartsWith("Aim at your suit", StringComparison.OrdinalIgnoreCase))
					{
						SetStatus("Aim at your visible suit to paint.", warn: false);
						UpdateUiState();
					}
					_strokeActive = false;
					return;
				}
				if (_statusMessage.StartsWith("Aim at your suit", StringComparison.OrdinalIgnoreCase))
				{
					SetStatus("Ready. Third-person paint mode is active.", warn: false);
				}
				if (_tool == EditorTool.Decal && (Object)(object)_loadedDecal == (Object)null)
				{
					WarnMissingDecal("world paint input");
					_tool = EditorTool.Paint;
					UpdateToolButtons();
					_strokeActive = false;
				}
				else
				{
					if (!_strokeActive)
					{
						BeginBrushStroke();
					}
					PaintWorldSurfaceBrush(editableTexture, hit, mirrorTarget);
				}
			}
		}

		private void BeginBrushStroke()
		{
			SaveUndo((_tool == EditorTool.Erase) ? "Erase" : "Brush stroke");
			ClearRedoHistory("brush stroke");
			_strokeActive = true;
			_brushStrokeSequence++;
			_brushStrokeSeed = (_brushStrokeSequence * 1103515245) ^ Mathf.RoundToInt(Time.unscaledTime * 1000f) ^ (_selectedSuitId * 397) ^ ((int)_brushShape * 7919);
			if (_brushStrokeSeed == 0)
			{
				_brushStrokeSeed = 1;
			}
		}

		private void HandleEyedropperInput(Texture2D texture, bool targetAvailable, Vector2 uv, string mode)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: 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_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			_strokeActive = false;
			_decalStampArmed = true;
			_suppressDecalPreviewUntilRelease = false;
			HideDecalPlacementPreview("eyedropper active", forceLog: false);
			if (!targetAvailable || (Object)(object)texture == (Object)null)
			{
				SetStatus("Aim at the suit to sample a color.", warn: false);
				LogEyedropperMiss(mode, targetAvailable ? "no editable texture" : "cursor miss");
				return;
			}
			Vector2Int pixel = TexturePixel(texture, uv);
			if (((Vector2Int)(ref pixel)).x < 0 || ((Vector2Int)(ref pixel)).y < 0 || ((Vector2Int)(ref pixel)).x >= ((Texture)texture).width || ((Vector2Int)(ref pixel)).y >= ((Texture)texture).height)
			{
				SetStatus("Aim at the suit to sample a color.", warn: false);
				LogEyedropperMiss(mode, $"invalid pixel {((Vector2Int)(ref pixel)).x},{((Vector2Int)(ref pixel)).y}");
				return;
			}
			Color pixel2 = texture.GetPixel(((Vector2Int)(ref pixel)).x, ((Vector2Int)(ref pixel)).y);
			pixel2.a = 1f;
			_brushColor = pixel2;
			_colorPicker?.SetColor(_brushColor, notify: false);
			UpdateColorUi();
			if ((Object)(object)_worldBrushMarkerMaterial != (Object)null)
			{
				_worldBrushMarkerMaterial.color = new Color(_brushColor.r, _brushColor.g, _brushColor.b, 0.85f);
			}
			EditorTool returnTool = (_tool = ResolveEyedropperReturnTool());
			_suppressPaintInputUntilRelease = true;
			_suppressDecalPreviewUntilRelease = false;
			if (_tool == EditorTool.Decal)
			{
				InvalidateDecalPreview("eyedropper return to decal");
			}
			else
			{
				HideDecalPlacementPreview("eyedropper sampled", forceLog: false);
			}
			SetStatus("Sampled " + ColorToHex(_brushColor) + ".", warn: false);
			UpdateToolButtons();
			UpdateBrushIndicator();
			LogEyedropperSampled(mode, texture, uv, pixel, returnTool);
		}

		private EditorTool ResolveEyedropperReturnTool()
		{
			if (_previousToolBeforeEyedropper == EditorTool.Decal && (Object)(object)_loadedDecal == (Object)null)
			{
				return EditorTool.Paint;
			}
			if (!IsReturnableEyedropperTool(_previousToolBeforeEyedropper))
			{
				return EditorTool.Paint;
			}
			return _previousToolBeforeEyedropper;
		}

		private void LogEyedropperSampled(string mode, Texture2D texture, Vector2 uv, Vector2Int pixel, EditorTool returnTool)
		{
			//IL_001b: 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)
			DrawableSuitsDiagnostics.Info($"EyedropperSampled: mode={mode}; pointerSource={_pointerSource}; uv={uv}; pixel={((Vector2Int)(ref pixel)).x},{((Vector2Int)(ref pixel)).y}; color={ColorToHex(_brushColor)}; returnTool={returnTool}; texture={((Object)texture).name} {((Texture)texture).width}x{((Texture)texture).height}");
		}

		private void LogEyedropperMiss(string mode, string reason)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			string text = mode + "|" + reason + "|source=" + _pointerSource;
			if (!(Time.unscaledTime - _lastEyedropperDiagnosticsTime < 0.75f) || !string.Equals(text, _lastEyedropperDiagnosticsKey, StringComparison.Ordinal))
			{
				_lastEyedropperDiagnosticsTime = Time.unscaledTime;
				_lastEyedropperDiagnosticsKey = text;
				DrawableSuitsDiagnostics.Info($"EyedropperMiss: mode={mode}; pointerSource={_pointerSource}; reason={reason}; cursor={_cursor}");
			}
		}

		private void HandleFillBucketInput(Texture2D texture, bool targetAvailable, Vector2 uv, MirrorPaintTarget mirrorTarget, string mode)
		{
			//IL_0173: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: 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_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			_strokeActive = false;
			HideDecalPlacementPreview("fill bucket active", forceLog: false);
			if (!_decalStampArmed)
			{
				return;
			}
			_decalStampArmed = false;
			_suppressDecalPreviewUntilRelease = true;
			if (!targetAvailable || (Object)(object)texture == (Object)null)
			{
				SetStatus(string.Equals(mode, "WorldThirdPerson", StringComparison.OrdinalIgnoreCase) ? "Aim at your visible suit to fill." : "Click the texture preview to fill.", warn: false);
				LogFillBucketSkipped(mode, targetAvailable ? "no editable texture" : "cursor miss", texture, uv, mirrorTarget, default(FillBucketStats), default(FillBucketStats));
				return;
			}
			Vector2Int seedPixel = TexturePixel(texture, uv);
			if (((Vector2Int)(ref seedPixel)).x < 0 || ((Vector2Int)(ref seedPixel)).y < 0 || ((Vector2Int)(ref seedPixel)).x >= ((Texture)texture).width || ((Vector2Int)(ref seedPixel)).y >= ((Texture)texture).height)
			{
				SetStatus("Aim at the suit to fill.", warn: false);
				LogFillBucketSkipped(mode, $"invalid seed pixel {((Vector2Int)(ref seedPixel)).x},{((Vector2Int)(ref seedPixel)).y}", texture, uv, mirrorTarget, default(FillBucketStats), default(FillBucketStats));
				return;
			}
			Color32[] pixels;
			try
			{
				pixels = texture.GetPixels32();
			}
			catch (Exception exception)
			{
				SetStatus("Fill failed; editable texture could not be read.", warn: true);
				DrawableSuitsDiagnostics.Exception($"FillBucket GetPixels32 failed. mode={mode}; texture={((Object)texture).name} {((Texture)texture).width}x{((Texture)texture).height}", exception);
				LogFillBucketSkipped(mode, "texture read failed", texture, uv, mirrorTarget, default(FillBucketStats), default(FillBucketStats));
				return;
			}
			SaveUndo("Color fill");
			ClearRedoHistory("color fill");
			Color32[] array = (Color32[])pixels.Clone();
			bool num = ShouldApplyMirror(texture, uv, mirrorTarget);
			HashSet<int> touchedPixels = (num ? new HashSet<int>() : null);
			FillBucketStats stats;
			bool flag = FloodFillBucket(texture, pixels, array, seedPixel, mirrored: false, touchedPixels, out stats);
			FillBucketStats stats2 = default(FillBucketStats);
			if (num)
			{
				Vector2Int seedPixel2 = TexturePixel(texture, mirrorTarget.Uv);
				if (((Vector2Int)(ref seedPixel2)).x >= 0 && ((Vector2Int)(ref seedPixel2)).y >= 0 && ((Vector2Int)(ref seedPixel2)).x < ((Texture)texture).width && ((Vector2Int)(ref seedPixel2)).y < ((Texture)texture).height)
				{
					flag |= FloodFillBucket(texture, pixels, array, seedPixel2, mirrored: true, touchedPixels, out stats2);
				}
			}
			if (!flag)
			{
				DropLastUndoEntry("Color fill wrote no pixels");
				SetStatus("Fill found no matching pixels to change.", warn: false);
				LogFillBucketSkipped(mode, "no pixels changed", texture, uv, mirrorTarget, stats, stats2);
				return;
			}
			texture.SetPixels32(array);
			texture.Apply(false, false);
			InvalidateDecalPreview("texture changed by fill bucket");
			if ((Object)(object)_previewMaterial != (Object)null)
			{
				_previewMaterial.mainTexture = (Texture)(object)texture;
			}
			DrawableSuitsPlugin.Registry.ApplyEditedTexture(_selectedSuitId, _designName, broadcast: false);
			RefreshTexturePanelPreview("FillBucket", forceLog: false);
			if (_mirrorEnabled && !mirrorTarget.Available)
			{
				SetStatus("Mirror target not found; filled primary region only.", warn: false);
			}
			else
			{
				SetStatus($"Filled {stats.WrittenPixels + stats2.WrittenPixels} pixels.", warn: false);
			}
			AddRecentColorFromBrush("Fill");
			LogFillBucketApplied(mode, texture, uv, mirrorTarget, stats, stats2);
			UpdateBrushIndicator();
		}

		private bool FloodFillBucket(Texture2D texture, Color32[] sourcePixels, Color32[] workingPixels, Vector2Int seedPixel, bool mirrored, HashSet<int> touchedPixels, out FillBucketStats stats)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_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_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: 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_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			stats = default(FillBucketStats);
			stats.Mirrored = mirrored;
			stats.SeedPixel = seedPixel;
			if ((Object)(object)texture == (Object)null || sourcePixels == null || workingPixels == null || sourcePixels.Length != ((Texture)texture).width * ((Texture)texture).height || workingPixels.Length != sourcePixels.Length)
			{
				return false;
			}
			int width = ((Texture)texture).width;
			int height = ((Texture)texture).height;
			int num = ((Vector2Int)(ref seedPixel)).y * width + ((Vector2Int)(ref seedPixel)).x;
			if (num < 0 || num >= sourcePixels.Length)
			{
				return false;
			}
			Color32 a = (stats.SeedColor = sourcePixels[num]);
			bool[] array = new bool[sourcePixels.Length];
			Queue<int> queue = new Queue<int>();
			array[num] = true;
			queue.Enqueue(num);
			while (queue.Count > 0)
			{
				int num2 = queue.Dequeue();
				stats.CheckedPixels++;
				Color32 b = sourcePixels[num2];
				if (RgbDistance01(a, b) > _fillTolerance)
				{
					continue;
				}
				stats.MatchedPixels++;
				int num3 = num2 % width;
				int num4 = num2 / width;
				if (TryMarkTouchedPixel(texture, num3, num4, touchedPixels))
				{
					Color val = Color32.op_Implicit(workingPixels[num2]);
					Color val2 = Color.Lerp(val, _brushColor, Mathf.Clamp01(_brushOpacity));
					val2.a = val.a;
					if (!ColorsNearlyEqual(val, val2))
					{
						workingPixels[num2] = Color32.op_Implicit(val2);
						stats.WrittenPixels++;
					}
				}
				else
				{
					stats.TouchedSkippedPixels++;
				}
				EnqueueFillNeighbor(num2 - 1, num3 > 0, array, queue);
				EnqueueFillNeighbor(num2 + 1, num3 < width - 1, array, queue);
				EnqueueFillNeighbor(num2 - width, num4 > 0, array, queue);
				EnqueueFillNeighbor(num2 + width, num4 < height - 1, array, queue);
			}
			return stats.WrittenPixels > 0;
		}

		private static void EnqueueFillNeighbor(int index, bool valid, bool[] visited, Queue<int> queue)
		{
			if (valid && index >= 0 && index < visited.Length && !visited[index])
			{
				visited[index] = true;
				queue.Enqueue(index);
			}
		}

		private static float RgbDistance01(Color32 a, Color32 b)
		{
			//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_0014: 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_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)
			float num = (float)(a.r - b.r) / 255f;
			float num2 = (float)(a.g - b.g) / 255f;
			float num3 = (float)(a.b - b.b) / 255f;
			return Mathf.Sqrt(num * num + num2 * num2 + num3 * num3) / 1.7320508f;
		}

		private static bool ColorsNearlyEqual(Color a, Color b)
		{
			//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_0019: 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_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_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)
			if (Mathf.Abs(a.r - b.r) < 0.001f && Mathf.Abs(a.g - b.g) < 0.001f && Mathf.Abs(a.b - b.b) < 0.001f)
			{
				return Mathf.Abs(a.a - b.a) < 0.001f;
			}
			return false;
		}

		private void LogFillBucketApplied(string mode, Texture2D texture, Vector2 uv, MirrorPaintTarget mirrorTarget, FillBucketStats primaryStats, FillBucketStats mirrorStats)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)texture == (Object)null))
			{
				Vector2Int val = TexturePixel(texture, uv);
				string text = DescribeMirrorTarget(texture, mirrorTarget);
				string text2 = $"applied|mode={mode}|seed={((Vector2Int)(ref val)).x},{((Vector2Int)(ref val)).y}|mirror={text}|tol={_fillTolerance:0.###}|written={primaryStats.WrittenPixels}+{mirrorStats.WrittenPixels}|checked={primaryStats.CheckedPixels}+{mirrorStats.CheckedPixels}|color={ColorToHex(_brushColor)}|opacity={_brushOpacity:0.##}";
				if (!(Time.unscaledTime - _lastFillBucketDiagnosticsTime < 0.5f) || !string.Equals(text2, _lastFillBucketDiagnosticsKey, StringComparison.Ordinal))
				{
					_lastFillBucketDiagnosticsTime = Time.unscaledTime;
					_lastFillBucketDiagnosticsKey = text2;
					DrawableSuitsDiagnostics.Info($"FillBucketApplied: {text2}; tool={_tool}; pointerSource={_pointerSource}; uv={uv}; seedColor={ColorToHex(Color32.op_Implicit(primaryStats.SeedColor))}; targetColor={ColorToHex(_brushColor)}; tolerance={_fillTolerance:0.###}; primaryMatched={primaryStats.MatchedPixels}; primaryTouchedSkipped={primaryStats.TouchedSkippedPixels}; mirroredSeed={((Vector2Int)(ref mirrorStats.SeedPixel)).x},{((Vector2Int)(ref mirrorStats.SeedPixel)).y}; mirroredSeedColor={ColorToHex(Color32.op_Implicit(mirrorStats.SeedColor))}; mirrorMatched={mirrorStats.MatchedPixels}; mirrorTouchedSkipped={mirrorStats.TouchedSkippedPixels}; cursor={_cursor}");
				}
			}
		}

		private void LogFillBucketSkipped(string mode, string reason, Texture2D texture, Vector2 uv, MirrorPaintTarget mirrorTarget, FillBucketStats primaryStats, FillBucketStats mirrorStats)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			Vector2Int val = (Vector2Int)(((Object)(object)texture != (Object)null) ? TexturePixel(texture, uv) : new Vector2Int(-1, -1));
			string text = (((Object)(object)texture != (Object)null) ? DescribeMirrorTarget(texture, mirrorTarget) : $"mirrorEnabled={mirrorTarget.Enabled}; mirrorAvailable={mirrorTarget.Available}; reason={mirrorTarget.Reason}");
			string text2 = $"skipped|mode={mode}|reason={reason}|seed={((Vector2Int)(ref val)).x},{((Vector2Int)(ref val)).y}|mirror={text}|tol={_fillTolerance:0.###}|source={_pointerSource}";
			if (!(Time.unscaledTime - _lastFillBucketDiagnosticsTime < 0.75f) || !string.Equals(text2, _lastFillBucketDiagnosticsKey, StringComparison.Ordinal))
			{
				_lastFillBucketDiagnosticsTime = Time.unscaledTime;
				_lastFillBucketDiagnosticsKey = text2;
				DrawableSuitsDiagnostics.Info($"FillBucketSkipped: {text2}; uv={uv}; checked={primaryStats.CheckedPixels}+{mirrorStats.CheckedPixels}; matched={primaryStats.MatchedPixels}+{mirrorStats.MatchedPixels}; written={primaryStats.WrittenPixels}+{mirrorStats.WrittenPixels}; cursor={_cursor}");
			}
		}

		private void HandleSinglePlacementStampInput(Texture2D texture, bool targetAvailable, Vector2 uv, MirrorPaintTarget mirrorTarget, string mode)
		{
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			_strokeActive = false;
			if (!_decalStampArmed)
			{
				return;
			}
			_decalStampArmed = false;
			_suppressDecalPreviewUntilRelease = true;
			HideDecalPlacementPreview("stamp input", forceLog: false);
			if (!targetAvailable || (Object)(object)texture == (Object)null)
			{
				if (string.Equals(mode, "WorldThirdPerson", StringComparison.OrdinalIgnoreCase))
				{
					SetStatus((_tool == EditorTool.Text) ? "Aim at your visible suit to stamp text." : ((_tool == EditorTool.Sticker) ? "Aim at your visible suit to stamp the sticker." : "Aim at your visible suit to stamp the decal."), warn: false);
				}
				return;
			}
			if (!TryGetActivePlacementStamp(out var stampTexture, out var failureReason))
			{
				if (_tool == EditorTool.Decal)
				{
					WarnMissingDecal(mode + " stamp");
					_tool = EditorTool.Paint;
					UpdateToolButtons();
				}
				else if (_tool == EditorTool.Sticker)
				{
					SetStatus("Sticker failed: " + failureReason + ".", warn: false);
					LogStickerStampSkipped(mode, failureReason);
				}
				else
				{
					SetStatus("Enter text before stamping.", warn: false);
					LogTextStampSkipped(mode, failureReason);
				}
				return;
			}
			string text = ((_tool == EditorTool.Text) ? "Text placed" : ((_tool == EditorTool.Sticker) ? "Sticker placed" : "Decal placed"));
			SaveUndo(text);
			ClearRedoHistory("placement stamp");
			if (PaintAtCursor(texture, uv, mirrorTarget))
			{
				if (_tool == EditorTool.Text)
				{
					LogTextStampCommitted(mode, texture, uv, mirrorTarget, stampTexture);
				}
				else if (_tool == EditorTool.Sticker)
				{
					LogStickerStampCommitted(mode, texture, uv, mirrorTarget, stampTexture);
				}
				else
				{
					LogDecalStampCommitted(mode, texture, uv, mirrorTarget);
				}
			}
			else
			{
				DropLastUndoEntry(text + " wrote no pixels");
			}
		}

		private void HandleWorldDecalStampInput(Texture2D texture, bool targetAvailable, RaycastHit hit, MirrorPaintTarget mirrorTarget)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			_strokeActive = false;
			if (!_decalStampArmed)
			{
				return;
			}
			_decalStampArmed = false;
			_suppressDecalPreviewUntilRelease = true;
			HideDecalPlacementPreview("decal stamp input", forceLog: false);
			if (!targetAvailable || (Object)(object)texture == (Object)null)
			{
				SetStatus("Aim at your visible suit to stamp the decal.", warn: false);
				LogDecalSurfaceStampSkipped("WorldThirdPerson", "cursor miss", texture, hit, mirrorTarget, null, default(TextSurfaceStampStats), default(TextSurfaceStampStats));
				return;
			}
			if (!TryGetActivePlacementStamp(out var stampTexture, out var failureReason))
			{
				WarnMissingDecal("WorldThirdPerson surface stamp");
				if (!string.IsNullOrWhiteSpace(failureReason))
				{
					SetStatus("Decal failed: " + failureReason + ".", warn: false);
				}
				_tool = EditorTool.Paint;
				UpdateToolButtons();
				return;
			}
			SaveUndo("Decal placed");
			ClearRedoHistory("world decal stamp");
			HashSet<int> touchedPixels = ((mirrorTarget.Enabled && mirrorTarget.Available) ? new HashSet<int>() : null);
			TextSurfaceStampStats stats;
			bool num = CompositeDecalSurfaceStamp(texture, stampTexture, ((RaycastHit)(ref hit)).point, ((RaycastHit)(ref hit)).normal, _decalRotation, mirrored: false, _brushOpacity, touchedPixels, out stats);
			bool flag = false;
			TextSurfaceStampStats stats2 = default(TextSurfaceStampStats);
			if (ShouldApplyMirror(texture, ((RaycastHit)(ref hit)).textureCoord, mirrorTarget) && TryGetMirrorWorldPlacement(mirrorTarget, out var point, out var normal))
			{
				flag = CompositeDecalSurfaceStamp(texture, stampTexture, point, normal, 0f - _decalRotation, mirrored: true, _brushOpacity, touchedPixels, out stats2);
			}
			if (!num && !flag)
			{
				LogDecalSurfaceStampSkipped("WorldThirdPerson", "surface projection wrote no pixels", texture, hit, mirrorTarget, stampTexture, stats, stats2);
				DropLastUndoEntry("Decal placed wrote no pixels");
				return;
			}
			texture.Apply(false, false);
			InvalidateDecalPreview("texture changed by decal surface stamp");
			DrawableSuitsPlugin.Registry.ApplyEditedTexture(_selectedSuitId, _designName, broadcast: false);
			RefreshTexturePanelPreview("WorldDecalStamp", forceLog: false);
			if (_mirrorEnabled && !mirrorTarget.Available)
			{
				SetStatus("Mirror target not found; applied primary only.", warn: false);
			}
			LogDecalSurfaceStampCommitted(texture, hit, mirrorTarget, stampTexture, stats, stats2);
			LogPaintApplied(texture, ((RaycastHit)(ref hit)).textureCoord, mirrorTarget);
			UpdateBrushIndicator();
		}

		private void HandleWorldTextStampInput(Texture2D texture, bool targetAvailable, RaycastHit hit, MirrorPaintTarget mirrorTarget)
		{
			//IL_004e: 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_00e0: 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_010f: 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_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			_strokeActive = false;
			if (!_decalStampArmed)
			{
				return;
			}
			_decalStampArmed = false;
			_suppressDecalPreviewUntilRelease = true;
			HideDecalPlacementPreview("text stamp input", forceLog: false);
			if (!targetAvailable || (Object)(object)texture == (Object)null)
			{
				SetStatus("Aim at your visible suit to stamp text.", warn: false);
				LogTextSurfaceStampSkipped("WorldThirdPerson", "cursor miss", texture, hit, mirrorTarget, null, default(TextSurfaceStampStats), default(TextSurfaceStampStats));
				return;
			}
			if (!TryGetTextStampTexture(out var texture2, out var failureReason))
			{
				SetStatus("Enter text before stamping.", warn: false);
				LogTextSurfaceStampSkipped("WorldThirdPerson", failureReason, texture, hit, mirrorTarget, texture2, default(TextSurfaceStampStats), default(TextSurfaceStampStats));
				return;
			}
			SaveUndo("Text placed");
			ClearRedoHistory("world text stamp");
			HashSet<int> touchedPixels = ((mirrorTarget.Enabled && mirrorTarget.Available) ? new HashSet<int>() : null);
			TextSurfaceStampStats stats;
			bool num = CompositeTextSurfaceStamp(texture, texture2, ((RaycastHit)(ref hit)).point, ((RaycastHit)(ref hit)).normal, _textRotation, mirrored: false, _brushOpacity, touchedPixels, out stats);
			bool flag = false;
			TextSurfaceStampStats stats2 = default(TextSurfaceStampStats);
			if (ShouldApplyMirror(texture, ((RaycastHit)(ref hit)).textureCoord, mirrorTarget) && TryGetMirrorWorldPlacement(mirrorTarget, out var point, out var normal))
			{
				flag = CompositeTextSurfaceStamp(texture, texture2, point, normal, 0f - _textRotation, mirrored: true, _brushOpacity, touchedPixels, out stats2);
			}
			if (!num && !flag)
			{
				LogTextSurfaceStampSkipped("WorldThirdPerson", "surface projection wrote no pixels", texture, hit, mirrorTarget, texture2, stats, stats2);
				DropLastUndoEntry("Text placed wrote no pixels");
				return;
			}
			texture.Apply(false, false);
			InvalidateDecalPreview("texture changed by text surface stamp");
			DrawableSuitsPlugin.Registry.ApplyEditedTexture(_selectedSuitId, _designName, broadcast: false);
			RefreshTexturePanelPreview("WorldTextStamp", forceLog: false);
			if (_mirrorEnabled && !mirrorTarget.Available)
			{
				SetStatus("Mirror target not found; applied primary only.", warn: false);
			}
			AddRecentColorFromBrush("Text");
			LogTextSurfaceStampCommitted(texture, hit, mirrorTarget, texture2, stats, stats2);
			LogPaintApplied(texture, ((RaycastHit)(ref hit)).textureCoord, mirrorTarget);
			UpdateBrushIndicator();
		}

		private void HandleWorldStickerStampInput(Texture2D texture, bool targetAvailable, RaycastHit hit, MirrorPaintTarget mirrorTarget)
		{
			//IL_004e: 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_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			_strokeActive = false;
			if (!_decalStampArmed)
			{
				return;
			}
			_decalStampArmed = false;
			_suppressDecalPreviewUntilRelease = true;
			HideDecalPlacementPreview("sticker stamp input", forceLog: false);
			if (!targetAvailable || (Object)(object)texture == (Object)null)
			{
				SetStatus("Aim at your visible suit to stamp the sticker.", warn: false);
				LogStickerSurfaceStampSkipped("WorldThirdPerson", "cursor miss", texture, hit, mirrorTarget, null, default(TextSurfaceStampStats), default(TextSurfaceStampStats));
				return;
			}
			if (!TryGetActivePlacementStamp(out var stampTexture, out var failureReason))
			{
				SetStatus("Sticker failed: " + failureReason + ".", warn: false);
				LogStickerSurfaceStampSkipped("WorldThirdPerson", failureReason, texture, hit, mirrorTarget, stampTexture, default(TextSurfaceStampStats), default(TextSurfaceStampStats));
				return;
			}
			SaveUndo("Sticker placed");
			ClearRedoHistory("world sticker stamp");
			HashSet<int> touchedPixels = ((mirrorTarget.Enabled && mirrorTarget.Available) ? new HashSet<int>() : null);
			TextSurfaceStampStats stats;
			bool num = CompositeDecalSurfaceStamp(texture, stampTexture, ((RaycastHit)(ref hit)).point, ((RaycastHit)(ref hit)).normal, _stickerRotation, mirrored: false, _brushOpacity, touchedPixels, out stats);
			bool flag = false;
			TextSurfaceStampStats stats2 = default(TextSurfaceStampStats);
			if (ShouldApplyMirror(texture, ((RaycastHit)(ref hit)).textureCoord, mirrorTarget) && TryGetMirrorWorldPlacement(mirrorTarget, out var point, out var normal))
			{
				flag = CompositeDecalSurfaceStamp(texture, stampTexture, point, normal, 0f - _stickerRotation, mirrored: true, _brushOpacity, touchedPixels, out stats2);
			}
			if (!num && !flag)
			{
				LogStickerSurfaceStampSkipped("WorldThirdPerson", "surface projection wrote no pixels", texture, hit, mirrorTarget, stampTexture, stats, stats2);
				DropLastUndoEntry("Sticker placed wrote no pixels");
				return;
			}
			texture.Apply(false, false);
			InvalidateDecalPreview("texture changed by sticker surface stamp");
			DrawableSuitsPlugin.Registry.ApplyEditedTexture(_selectedSuitId, _designName, broadcast: false);
			RefreshTexturePanelPreview("WorldStickerStamp", forceLog: false);
			if (_mirrorEnabled && !mirrorTarget.Available)
			{
				SetStatus("Mirror target not found; applied primary sticker only.", warn: false);
			}
			AddRecentColorFromBrush("Sticker");
			LogStickerSurfaceStampCommitted(texture, hit, mirrorTarget, stampTexture, stats, stats2);
			LogPaintApplied(texture, ((RaycastHit)(ref hit)).textureCoord, mirrorTarget);
			UpdateBrushIndicator();
		}

		private void LogPaintAttemptIfNeeded(string reason, bool overPreview, bool uvAvailable, Vector2 uv, Texture2D texture, MirrorPaintTarget mirrorTarget, bool force)
		{
			//IL_0013: 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_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			string text = "none";
			if (uvAvailable && (Object)(object)texture != (Object)null)
			{
				int num = Mathf.RoundToInt(uv.x * (float)(((Texture)texture).width - 1));
				int num2 = Mathf.RoundToInt(uv.y * (float)(((Texture)texture).height - 1));
				text = $"{num},{num2}";
			}
			string text2 = (uvAvailable ? DescribeMirrorTarget(texture, mirrorTarget) : $"mirrorEnabled={_mirrorEnabled}");
			string text3 = $"{reason}|tool={_tool}|shape={_brushShape}|seed={_brushStrokeSeed}|over={overPreview}|uv={uvAvailable}:{uv}|pixel={text}|{text2}|brush={Mathf.RoundToInt(EffectiveBrushRadiusPixels())}|opacity={_brushOpacity:0.##}|decal={(Object)(object)_loadedDecal != (Object)null}|source={_pointerSource}";
			if (force || !(Time.unscaledTime - _lastPaintDiagnosticsTime < 0.75f) || !string.Equals(text3, _lastPaintDiagnosticsKey, StringComparison.Ordinal))
			{
				_lastPaintDiagnosticsTime = Time.unscaledTime;
				_lastPaintDiagnosticsKey = text3;
				Gamepad current = Gamepad.current;
				string text4 = ((current != null) ? ((InputControl<float>)(object)current.rightTrigger).ReadValue().ToString("0.###") : "null");
				DrawableSuitsDiagnostics.Info($"PaintAttempt: {text3}; cursor={_cursor}; texture={DescribeEditableTexture()}; mouseDown={DrawableSuitsInput.IsLeftMousePressed()}; trigger={text4}");
			}
		}

		private void LogPaintApplied(Texture2D texture, Vector2 uv, MirrorPaintTarget mirrorTarget, BrushShapeStats primaryBrushStats = default(BrushShapeStats), BrushShapeStats mirrorBrushStats = default(BrushShapeStats))
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.RoundToInt(uv.x * (float)(((Texture)texture).width - 1));
			int num2 = Mathf.RoundToInt(uv.y * (float)(((Texture)texture).height - 1));
			string text = ((primaryBrushStats.Available || mirrorBrushStats.Available) ? $"|primaryAccepted={primaryBrushStats.AcceptedSamples}|primaryRandomSkipped={primaryBrushStats.RandomSkippedSamples}|primaryWritten={primaryBrushStats.WrittenPixels}|mirrorAccepted={mirrorBrushStats.AcceptedSamples}|mirrorRandomSkipped={mirrorBrushStats.RandomSkippedSamples}|mirrorWritten={mirrorBrushStats.WrittenPixels}" : string.Empty);
			string text2 = $"applied|tool={_tool}|shape={_brushShape}|seed={_brushStrokeSeed}|pixel={num},{num2}|{DescribeMirrorTarget(texture, mirrorTarget)}|brush={Mathf.RoundToInt(EffectiveBrushRadiusPixels())}|opacity={_brushOpacity:0.##}|decal={(Object)(object)_loadedDecal != (Object)null}{text}";
			if (!(Time.unscaledTime - _lastPaintDiagnosticsTime < 0.5f) || !string.Equals(text2, _lastPaintDiagnosticsKey, StringComparison.Ordinal))
			{
				_lastPaintDiagnosticsTime = Time.unscaledTime;
				_lastPaintDiagnosticsKey = text2;
				DrawableSuitsDiagnostics.Info($"PaintApplied: {text2}; texture={((Object)texture).name} {((Texture)texture).width}x{((Texture)texture).height}; uv={uv}; pointerSource={_pointerSource}");
			}
		}

		private void LogBrushSurfaceStrokeApplied(Texture2D texture, RaycastHit hit, MirrorPaintTarget mirrorTarget, TextSurfaceStampStats primaryStats, TextSurfaceStampStats mirrorStats, float primaryRadius, float mirrorRadius, string fallbackReason)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)texture == (Object)null))
			{
				Vector2Int val = TexturePixel(texture, ((RaycastHit)(ref hit)).textureCoord);
				string text = $"applied|tool={_tool}|shape={_brushShape}|seed={_brushStrokeSeed}|pixel={((Vector2Int)(ref val)).x},{((Vector2Int)(ref val)).y}|mirror={DescribeMirrorTarget(texture, mirrorTarget)}|brush={Mathf.RoundToInt(EffectiveBrushRadiusPixels())}|opacity={_brushOpacity:0.##}|primaryWritten={primaryStats.WrittenPixels}|mirrorWritten={mirrorStats.WrittenPixels}|primaryAccepted={primaryStats.AcceptedSamples}|mirrorAccepted={mirrorStats.AcceptedSamples}|primaryRandomSkipped={primaryStats.RandomSkippedSamples}|mirrorRandomSkipped={mirrorStats.RandomSkippedSamples}|primaryCells={primaryStats.RasterizedCells}|mirrorCells={mirrorStats.RasterizedCells}|primarySeams={primaryStats.SeamSkippedCells}|mirrorSeams={mirrorStats.SeamSkippedCells}|radius={primaryRadius:0.####}";
				if (!(Time.unscaledTime - _lastBrushSurfaceDiagnosticsTime < 0.5f) || !string.Equals(text, _lastBrushSurfaceDiagnosticsKey, StringComparison.Ordinal))
				{
					_lastBrushSurfaceDiagnosticsTime = Time.unscaledTime;
					_lastBrushSurfaceDiagnosticsKey = text;
					DrawableSuitsDiagnostics.Info($"BrushSurfaceStrokeApplied: {text}; mode=WorldThirdPerson; pointerSource={_pointerSource}; uv={((RaycastHit)(ref hit)).textureCoord}; hitPoint={((RaycastHit)(ref hit)).point}; hitNormal={((RaycastHit)(ref hit)).normal}; primaryRadius={primaryRadius:0.####}; mirrorRadius={mirrorRadius:0.####}; primarySamples={primaryStats.ProjectionSamples}; primaryHits={primaryStats.SurfaceHits}; primaryAlpha={primaryStats.AlphaPixels}; primarySkipped={primaryStats.SkippedPixels}; primaryOffSuit={primaryStats.OffSuitSamples}; primaryWorldSize={primaryStats.WorldWidth:0.###}x{primaryStats.WorldHeight:0.###}; mirrorSamples={mirrorStats.ProjectionSamples}; mirrorHits={mirrorStats.SurfaceHits}; mirrorAlpha={mirrorStats.AlphaPixels}; mirrorSkipped={mirrorStats.SkippedPixels}; mirrorOffSuit={mirrorStats.OffSuitSamples}; mirrorWorldSize={mirrorStats.WorldWidth:0.###}x{mirrorStats.WorldHeight:0.###}; fallback={fallbackReason}; cursor={_cursor}");
				}
			}
		}

		private void LogBrushSurfaceStrokeSkipped(string reason, Texture2D texture, RaycastHit hit, MirrorPaintTarget mirrorTarget, TextSurfaceStampStats primaryStats, TextSurfaceStampStats mirrorStats, float primaryRadius, float mirrorRadius, string fallbackReason)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			Vector2Int val = (Vector2Int)(((Object)(object)texture != (Object)null) ? TexturePixel(texture, ((RaycastHit)(ref hit)).textureCoord) : new Vector2Int(-1, -1));
			string text = $"skipped|reason={reason}|tool={_tool}|shape={_brushShape}|seed={_brushStrokeSeed}|pixel={((Vector2Int)(ref val)).x},{((Vector2Int)(ref val)).y}|mirror={DescribeMirrorTarget(texture, mirrorTarget)}|brush={Mathf.RoundToInt(EffectiveBrushRadiusPixels())}|primaryWritten={primaryStats.WrittenPixels}|mirrorWritten={mirrorStats.WrittenPixels}|primaryAccepted={primaryStats.AcceptedSamples}|mirrorAccepted={mirrorStats.AcceptedSamples}|primaryRandomSkipped={primaryStats.RandomSkippedSamples}|mirrorRandomSkipped={mirrorStats.RandomSkippedSamples}|primaryCells={primaryStats.RasterizedCells}|mirrorCells={mirrorStats.RasterizedCells}";
			if (!(Time.unscaledTime - _lastBrushSurfaceDiagnosticsTime < 0.75f) || !string.Equals(text, _lastBrushSurfaceDiagnosticsKey, StringComparison.Ordinal))
			{
				_lastBrushSurfaceDiagnosticsTime = Time.unscaledTime;
				_lastBrushSurfaceDiagnosticsKey = text;
				DrawableSuitsDiagnostics.Info($"BrushSurfaceStrokeSkipped: {text}; mode=WorldThirdPerson; pointerSource={_pointerSource}; uv={((RaycastHit)(ref hit)).textureCoord}; hitPoint={((RaycastHit)(ref hit)).point}; hitNormal={((RaycastHit)(ref hit)).normal}; primaryRadius={primaryRadius:0.####}; mirrorRadius={mirrorRadius:0.####}; primarySamples={primaryStats.ProjectionSamples}; primaryHits={primaryStats.SurfaceHits}; primarySkipped={primaryStats.SkippedPixels}; primaryOffSuit={primaryStats.OffSuitSamples}; primarySeams={primaryStats.SeamSkippedCells}; mirrorSamples={mirrorStats.ProjectionSamples}; mirrorHits={mirrorStats.SurfaceHits}; mirrorSkipped={mirrorStats.SkippedPixels}; mirrorOffSuit={mirrorStats.OffSuitSamples}; mirrorSeams={mirrorStats.SeamSkippedCells}; fallback={fallbackReason}; cursor={_cursor}");
			}
		}

		private bool IsCursorOverEditorPanel()
		{
			//IL_004b: 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)
			if ((Object)(object)_designCodePanelObject != (Object)null && _designCodePanelObject.activeInHierarchy && RectTransformUtility.RectangleContainsScreenPoint(_designCodePanelObject.GetComponent<RectTransform>(), _cursor, (Camera)null))
			{
				return true;
			}
			if ((Object)(object)_panelRect != (Object)null)
			{
				return RectTransformUtility.RectangleContainsScreenPoint(_panelRect, _cursor, (Camera)null);
			}
			return false;
		}

		private bool IsCursorOverPreviewViewport()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_previewViewportRect != (Object)null)
			{
				return RectTransformUtility.RectangleContainsScreenPoint(_previewViewportRect, _cursor, (Camera)null);
			}
			return false;
		}

		private Rect GetUvPanelViewRect()
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Clamp(_uvPanelZoom, 1f, 8f);
			float num2 = 1f / num;
			float num3 = Mathf.Clamp(_uvPanelCenter.x - num2 * 0.5f, 0f, Mathf.Max(0f, 1f - num2));
			float num4 = Mathf.Clamp(_uvPanelCenter.y - num2 * 0.5f, 0f, Mathf.Max(0f, 1f - num2));
			return new Rect(num3, num4, num2, num2);
		}

		private static int NormalizeUvPanelRotation(int quarterTurns)
		{
			int num = quarterTurns % 4;
			if (num >= 0)
			{
				return num;
			}
			return num + 4;
		}

		private static int UvPanelRotationDegrees(int quarterTurns)
		{
			return NormalizeUvPanelRotation(quarterTurns) * 90;
		}

		private static Vector2 PanelNormalizedToViewNormalized(Vector2 panelNormalized, int quarterTurns)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_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)
			return (Vector2)(NormalizeUvPanelRotation(quarterTurns) switch
			{
				1 => new Vector2(panelNormalized.y, 1f - panelNormalized.x), 
				2 => new Vector2(1f - panelNormalized.x, 1f - panelNormalized.y), 
				3 => new Vector2(1f - panelNormalized.y, panelNormalized.x), 
				_ => panelNormalized, 
			});
		}

		private static Vector2 ViewNormalizedToPanelNormalized(Vector2 viewNormalized, int quarterTurns)
		{
			//IL_0022: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			return (Vector2)(NormalizeUvPanelRotation(quarterTurns) switch
			{
				1 => new Vector2(1f - viewNormalized.y, viewNormalized.x), 
				2 => new Vector2(1f - viewNormalized.x, 1f - viewNormalized.y), 
				3 => new Vector2(viewNormalized.y, 1f - viewNormalized.x), 
				_ => viewNormalized, 
			});
		}

		private static Vector2 PanelVectorToViewVector(Vector2 panelVector, int quarterTurns)
		{
			//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_002a: 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_0037: 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_0044: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			return (Vector2)(NormalizeUvPanelRotation(quarterTurns) switch
			{
				1 => new Vector2(panelVector.y, 0f - panelVector.x), 
				2 => new Vector2(0f - panelVector.x, 0f - panelVector.y), 
				3 => new Vector2(0f - panelVector.y, panelVector.x), 
				_ => panelVector, 
			});
		}

		private static Vector2 ViewVectorToPanelVector(Vector2 viewVector, int quarterTurns)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_0037: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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)
			return (Vector2)(NormalizeUvPanelRotation(quarterTurns) switch
			{
				1 => new Vector2(0f - viewVector.y, viewVector.x), 
				2 => new Vector2(0f - viewVector.x, 0f - viewVector.y), 
				3 => new Vector2(viewVector.y, 0f - viewVector.x), 
				_ => viewVector, 
			});
		}

		private void ResetUvPanelView(string reason, bool forceLog)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			_uvPanelZoom = 1f;
			_uvPanelCenter = new Vector2(0.5f, 0.5f);
			_uvPanelRotationQuarterTurns = 0;
			Texture2D texture = ((_selectedSuitId >= 0) ? DrawableSuitsPlugin.Registry.GetEditableTexture(_selectedSuitId) : null);
			ApplyUvPanelViewToPreviewImage(texture);
			LogUvPanelViewChanged("Reset", default(Vector2), reason, forceLog);
			InvalidateDecalPreview("uv panel view reset");
		}

		private void EnsureUvPanelViewForTexture(Texture2D texture, string reason)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)texture == (Object)null)
			{
				_uvPanelTextureWidth = 0;
				_uvPanelTextureHeight = 0;
			}
			else if (_uvPanelTextureWidth != ((Texture)texture).width || _uvPanelTextureHeight != ((Texture)texture).height)
			{
				_uvPanelTextureWidth = ((Texture)texture).width;
				_uvPanelTextureHeight = ((Texture)texture).height;
				ResetUvPanelView("texture size changed (" + reason + ")", forceLog: true);
			}
			else
			{
				SetUvPanelView(_uvPanelZoom, _uvPanelCenter, "Clamp", default(Vector2), reason, forceLog: false);
			}
		}

		private void ApplyUvPanelViewToPreviewImage(Texture2D texture)
		{
			//IL_003a: 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)
			if (!((Object)(object)_previewImage == (Object)null))
			{
				((RawImage)_previewImage).uvRect = (Rect)(((Object)(object)texture != (Object)null) ? GetUvPanelViewRect() : new Rect(0f, 0f, 10f, 10f));
				_previewImage.SetUvRotation(((Object)(object)texture != (Object)null) ? _uvPanelRotationQuarterTurns : 0);
			}
		}

		private void SetUvPanelView(float zoom, Vector2 center, string source, Vector2 anchorUv, string reason, bool forceLog)
		{
			//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_0047: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: 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)
			float uvPanelZoom = _uvPanelZoom;
			Vector2 uvPanelCenter = _uvPanelCenter;
			_uvPanelZoom = Mathf.Clamp(zoom, 1f, 8f);
			float num = 1f / _uvPanelZoom;
			float num2 = num * 0.5f;
			float num3 = 1f - num * 0.5f;
			_uvPanelCenter = new Vector2(Mathf.Clamp(center.x, num2, num3), Mathf.Clamp(center.y, num2, num3));
			Texture2D texture = ((_selectedSuitId >= 0) ? DrawableSuitsPlugin.Registry.GetEditableTexture(_selectedSuitId) : null);
			ApplyUvPanelViewToPreviewImage(texture);
			int num4;
			if (Mathf.Approximately(uvPanelZoom, _uvPanelZoom))
			{
				Vector2 val = uvPanelCenter - _uvPanelCenter;
				num4 = ((((Vector2)(ref val)).sqrMagnitude > 1E-07f) ? 1 : 0);
				if (num4 == 0)
				{
					goto IL_00cb;
				}
			}
			else
			{
				num4 = 1;
			}
			InvalidateDecalPreview("uv panel view changed");
			goto IL_00cb;
			IL_00cb:
			if (((uint)num4 | (forceLog ? 1u : 0u)) != 0)
			{
				LogUvPanelViewChanged(source, anchorUv, reason, forceLog);
			}
		}

		private void RotateUvPanel(int deltaQuarterTurns, string source)
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			if (CanHandleUvPanelRotationShortcuts())
			{
				int uvPanelRotationQuarterTurns = _uvPanelRotationQuarterTurns;
				_uvPanelRotationQuarterTurns = NormalizeUvPanelRotation(_uvPanelRotationQuarterTurns + deltaQuarterTurns);
				if (uvPanelRotationQuarterTurns != _uvPanelRotationQuarterTurns)
				{
					Texture2D texture = ((_selectedSuitId >= 0) ? DrawableSuitsPlugin.Registry.GetEditableTexture(_selectedSuitId) : null);
					ApplyUvPanelViewToPreviewImage(texture);
					InvalidateDecalPreview("uv panel rotation shortcut " + source);
					SetStatus($"UV panel rotation: {UvPanelRotationDegrees(_uvPanelRotationQuarterTurns)} deg.", warn: false);
					DrawableSuitsDiagnostics.Info(string.Format("UvPanelRotationChanged: source={0}; previous={1}; new={2}; zoom={3:0.###}; center={4}; uvRect={5}; pointerSource={6}; cursor={7}; previewImageUvRect={8}", source, UvPanelRotationDegrees(uvPanelRotationQuarterTurns), UvPanelRotationDegrees(_uvPanelRotationQuarterTurns), _uvPanelZoom, _uvPanelCenter, GetUvPanelViewRect(), _pointerSource, _cursor, ((Object)(object)_previewImage != (Object)null) ? ((object)((RawImage)_previewImage).uvRect/*cast due to .constrained prefix*/).ToString() : "null"));
				}
			}
		}

		private bool ZoomUvPanelAtCursor(float factor, string source, string reason)
		{
			//IL_0002: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetTexturePreviewNormalized(_cursor, out var normalized))
			{
				return false;
			}
			if (!TryGetTexturePreviewUv(_cursor, out var uv))
			{
				return false;
			}
			float num = Mathf.Clamp(_uvPanelZoom * factor, 1f, 8f);
			if (Mathf.Approximately(num, _uvPanelZoom))
			{
				return true;
			}
			Vector2 val = PanelNormalizedToViewNormalized(normalized, _uvPanelRotationQuarterTurns);
			float num2 = 1f / num;
			float num3 = uv.x - val.x * num2;
			float num4 = uv.y - val.y * num2;
			Vector2 center = default(Vector2);
			((Vector2)(ref center))..ctor(num3 + num2 * 0.5f, num4 + num2 * 0.5f);
			SetUvPanelView(num, center, source, uv, reason, forceLog: false);
			return true;
		}

		private bool PanUvPanelFromMouseDelta(string source)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_previewViewportRect == (Object)null)
			{
				return false;
			}
			Vector2 rectTransformScreenSize = GetRectTransformScreenSize(_previewViewportRect);
			if (rectTransformScreenSize.x <= 0f || rectTransformScreenSize.y <= 0f)
			{
				return false;
			}
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(DrawableSuitsInput.MouseDeltaX(), DrawableSuitsInput.MouseDeltaY());
			if (((Vector2)(ref val)).sqrMagnitude <= 0.001f)
			{
				return true;
			}
			Rect uvPanelViewRect = GetUvPanelViewRect();
			Vector2 val2 = PanelVectorToViewVector(new Vector2(val.x / rectTransformScreenSize.x, val.y / rectTransformScreenSize.y), _uvPanelRotationQuarterTurns);
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(val2.x * ((Rect)(ref uvPanelViewRect)).width, val2.y * ((Rect)(ref uvPanelViewRect)).height);
			SetUvPanelView(_uvPanelZoom, _uvPanelCenter - val3, source, (Vector2)(_lastPreviewUvAvailable ? _lastPreviewUv : default(Vector2)), "right mouse pan", forceLog: false);
			return true;
		}

		private bool PanUvPanelFromGamepadStick(Vector2 stick, string source)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			if (((Vector2)(ref stick)).sqrMagnitude <= 0.040000003f)
			{
				return false;
			}
			Rect uvPanelViewRect = GetUvPanelViewRect();
			Vector2 val = PanelVectorToViewVector(stick * (1.8f * Time.unscaledDeltaTime), _uvPanelRotationQuarterTurns);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(val.x * ((Rect)(ref uvPanelViewRect)).width, val.y * ((Rect)(ref uvPanelViewRect)).height);
			if (((Vector2)(ref val2)).sqrMagnitude <= 1E-07f)
			{
				return false;
			}
			SetUvPanelView(_uvPanelZoom, _uvPanelCenter + val2, source, (Vector2)(_lastPreviewUvAvailable ? _lastPreviewUv : default(Vector2)), "right stick pan", forceLog: false);
			return true;
		}

		private bool HandleUvPanelViewInput(float mouseScroll, Gamepad gamepad, string targetMode)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			if (!IsCursorOverPreviewViewport())
			{
				return false;
			}
			bool flag = false;
			if (Mathf.Abs(mouseScroll) > 0.01f)
			{
				float factor = Mathf.Pow(1.18f, mouseScroll);
				flag |= ZoomUvPanelAtCursor(factor, "MouseWheel", targetMode);
			}
			if (gamepad != null)
			{
				Vector2 val = ((InputControl<Vector2>)(object)gamepad.dpad).ReadValue();
				if (Mathf.Abs(val.y) > 0.35f)
				{
					float factor2 = Mathf.Pow(1.9f, val.y * Time.unscaledDeltaTime);
					flag |= ZoomUvPanelAtCursor(factor2, "GamepadDpad", targetMode);
				}
				flag |= PanUvPanelFromGamepadStick(((InputControl<Vector2>)(object)gamepad.rightStick).ReadValue(), "GamepadRightStickPan");
			}
			if (DrawableSuitsInput.IsRightMousePressed())
			{
				flag |= PanUvPanelFromMouseDelta("MouseRightDrag");
			}
			return flag;
		}

		private unsafe void LogUvPanelViewChanged(string source, Vector2 anchorUv, string reason, bool forceLog)
		{
			//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_00ef: 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_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			Rect uvPanelViewRect = GetUvPanelViewRect();
			string text = $"{source}|zoom={_uvPanelZoom:0.###}|center={_uvPanelCenter.x:0.####},{_uvPanelCenter.y:0.####}|view={((Rect)(ref uvPanelViewRect)).x:0.####},{((Rect)(ref uvPanelViewRect)).y:0.####},{((Rect)(ref uvPanelViewRect)).width:0.####},{((Rect)(ref uvPanelViewRect)).height:0.####}|reason={reason}";
			if (forceLog || !(Time.unscaledTime - _lastUvPanelViewLogTime < 0.5f) || !string.Equals(text, _lastUvPanelViewLogKey, StringComparison.Ordinal))
			{
				_lastUvPanelViewLogTime = Time.unscaledTime;
				_lastUvPanelViewLogKey = text;
				DrawableSuitsDiagnostics.Info(string.Format("UvPanelViewChanged: source={0}; reason={1}; zoom={2:0.###}; center={3}; rotation={4}; uvRect={5}; anchorUv={6}; pointerSource={7}; cursor={8}; previewImageUvRect={9}", source, reason, _uvPanelZoom, _uvPanelCenter, UvPanelRotationDegrees(_uvPanelRotationQuarterTurns), uvPanelViewRect, (anchorUv == default(Vector2)) ? "none" : ((object)(*(Vector2*)(&anchorUv))/*cast due to .constrained prefix*/).ToString(), _pointerSource, _cursor, ((Object)(object)_previewImage != (Object)null) ? ((object)((RawImage)_previewImage).uvRect/*cast due to .constrained prefix*/).ToString() : "null"));
			}
		}

		private bool TryGetTexturePreviewNormalized(Vector2 screenPosition, out Vector2 normalized)
		{
			//IL_0001: 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_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_0054: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			normalized = default(Vector2);
			if ((Object)(object)_previewViewportRect == (Object)null)
			{
				return false;
			}
			Vector2 val = default(Vector2);
			if (!RectTransformUtility.ScreenPointToLocalPointInRectangle(_previewViewportRect, screenPosition, (Camera)null, ref val))
			{
				return false;
			}
			Rect rect = _previewViewportRect.rect;
			if (((Rect)(ref rect)).width <= 0f || ((Rect)(ref rect)).height <= 0f)
			{
				return false;
			}
			float num = (val.x - ((Rect)(ref rect)).xMin) / ((Rect)(ref rect)).width;
			float num2 = (val.y - ((Rect)(ref rect)).yMin) / ((Rect)(ref rect)).height;
			if (num < 0f || num > 1f || num2 < 0f || num2 > 1f)
			{
				return false;
			}
			normalized = new Vector2(Mathf.Clamp01(num), Mathf.Clamp01(num2));
			return true;
		}

		private bool TryTextureUvToPreviewLocal(Vector2 uv, out Vector2 localPoint)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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_005d: 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_009b: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			localPoint = default(Vector2);
			if ((Object)(object)_previewViewportRect == (Object)null)
			{
				return false;
			}
			Rect uvPanelViewRect = GetUvPanelViewRect();
			if (uv.x < ((Rect)(ref uvPanelViewRect)).xMin - 0.0001f || uv.x > ((Rect)(ref uvPanelViewRect)).xMax + 0.0001f || uv.y < ((Rect)(ref uvPanelViewRect)).yMin - 0.0001f || uv.y > ((Rect)(ref uvPanelViewRect)).yMax + 0.0001f)
			{
				return false;
			}
			Vector2 val = ViewNormalizedToPanelNormalized(new Vector2(Mathf.InverseLerp(((Rect)(ref uvPanelViewRect)).xMin, ((Rect)(ref uvPanelViewRect)).xMax, uv.x), Mathf.InverseLerp(((Rect)(ref uvPanelViewRect)).yMin, ((Rect)(ref uvPanelViewRect)).yMax, uv.y)), _uvPanelRotationQuarterTurns);
			Rect rect = _previewViewportRect.rect;
			localPoint = new Vector2(Mathf.Lerp(((Rect)(ref rect)).xMin, ((Rect)(ref rect)).xMax, val.x), Mathf.Lerp(((Rect)(ref rect)).yMin, ((Rect)(ref rect)).yMax, val.y));
			return true;
		}

		private bool TryGetTexturePreviewUv(Vector2 screenPosition, out Vector2 uv)
		{
			//IL_0001: 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_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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			uv = default(Vector2);
			_lastPreviewUvAvailable = false;
			if (!TryGetTexturePreviewNormalized(screenPosition, out var normalized))
			{
				return false;
			}
			Rect uvPanelViewRect = GetUvPanelViewRect();
			Vector2 val = PanelNormalizedToViewNormalized(normalized, _uvPanelRotationQuarterTurns);
			uv = new Vector2(Mathf.Clamp01(((Rect)(ref uvPanelViewRect)).xMin + val.x * ((Rect)(ref uvPanelViewRect)).width), Mathf.Clamp01(((Rect)(ref uvPanelViewRect)).yMin + val.y * ((Rect)(ref uvPanelViewRect)).height));
			_lastPreviewUv = uv;
			_lastPreviewUvAvailable = true;
			return true;
		}

		private bool PaintAtCursor(Texture2D texture, Vector2 uv, MirrorPaintTarget mirrorTarget)
		{
			//IL_001d: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)texture == (Object)null)
			{
				RefreshEditorReadiness("paint preflight failed");
				UpdateUiState();
				return false;
			}
			bool flag = ShouldApplyMirror(texture, uv, mirrorTarget);
			HashSet<int> touchedPixels = (flag ? new HashSet<int>() : null);
			bool flag2 = true;
			BrushShapeStats stats = default(BrushShapeStats);
			BrushShapeStats stats2 = default(BrushShapeStats);
			switch (_tool)
			{
			case EditorTool.Paint:
				flag2 = ApplyDirectBrush(texture, uv, mirrored: false, touchedPixels, out stats);
				if (flag)
				{
					flag2 |= ApplyDirectBrush(texture, mirrorTarget.Uv, mirrored: true, touchedPixels, out stats2);
				}
				break;
			case EditorTool.Erase:
				flag2 = ApplyDirectBrush(texture, uv, mirrored: false, touchedPixels, out stats);
				if (flag)
				{
					flag2 |= ApplyDirectBrush(texture, mirrorTarget.Uv, mirrored: true, touchedPixels, out stats2);
				}
				break;
			case EditorTool.Decal:
				flag2 = ApplyDecal(texture, uv, mirrored: false, touchedPixels);
				if (flag)
				{
					flag2 |= ApplyDecal(texture, mirrorTarget.Uv, mirrored: true, touchedPixels);
				}
				_strokeActive = false;
				break;
			case EditorTool.Text:
				flag2 = ApplyTextStamp(texture, uv, mirrored: false, touchedPixels);
				if (flag)
				{
					flag2 |= ApplyTextStamp(texture, mirrorTarget.Uv, mirrored: true, touchedPixels);
				}
				_strokeActive = false;
				break;
			case EditorTool.Sticker:
				flag2 = ApplyStickerStamp(texture, uv, mirrored: false, touchedPixels);
				if (flag)
				{
					flag2 |= ApplyStickerStamp(texture, mirrorTarget.Uv, mirrored: true, touchedPixels);
				}
				_strokeActive = false;
				break;
			default:
				flag2 = false;
				break;
			}
			if (!flag2)
			{
				return false;
			}
			texture.Apply(false, false);
			InvalidateDecalPreview("texture changed by paint");
			if ((Object)(object)_previewMaterial != (Object)null)
			{
				_previewMaterial.mainTexture = (Texture)(object)texture;
			}
			DrawableSuitsPlugin.Registry.ApplyEditedTexture(_selectedSuitId, _designName, broadcast: false);
			RefreshTexturePanelPreview("PaintAtCursor", forceLog: false);
			if (_mirrorEnabled && !mirrorTarget.Available)
			{
				SetStatus("Mirror target not found; applied primary only.", warn: false);
			}
			if (_tool == EditorTool.Paint)
			{
				AddRecentColorFromBrush("Paint");
			}
			else if (_tool == EditorTool.Text)
			{
				AddRecentColorFromBrush("Text");
			}
			else if (_tool == EditorTool.Sticker)
			{
				AddRecentColorFromBrush("Sticker");
			}
			LogPaintApplied(texture, uv, mirrorTarget, stats, stats2);
			UpdateBrushIndicator();
			return true;
		}

		private static string CombineReasons(params string[] reasons)
		{
			if (reasons == null || reasons.Length == 0)
			{
				return string.Empty;
			}
			string text = string.Empty;
			foreach (string text2 in reasons)
			{
				if (!string.IsNullOrWhiteSpace(text2))
				{
					text = (string.IsNullOrWhiteSpace(text) ? text2 : (text + "; " + text2));
				}
			}
			return text;
		}

		private bool PaintWorldSurfaceBrush(Texture2D texture, RaycastHit hit, MirrorPaintTarget mirrorTarget)
		{
			//IL_0031: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: 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_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)texture == (Object)null)
			{
				RefreshEditorReadiness("world brush preflight failed");
				UpdateUiState();
				return false;
			}
			if (_tool != EditorTool.Paint && _tool != EditorTool.Erase)
			{
				return PaintAtCursor(texture, ((RaycastHit)(ref hit)).textureCoord, mirrorTarget);
			}
			if (_tool == EditorTool.Erase && (Object)(object)DrawableSuitsPlugin.Registry.GetOrCreateState(_selectedSuitId)?.BaseTexture == (Object)null)
			{
				LogBrushSurfaceStrokeSkipped("base texture missing", texture, hit, mirrorTarget, default(TextSurfaceStampStats), default(TextSurfaceStampStats), 0f, 0f, "base texture missing");
				return false;
			}
			if (_brushShape == BrushShape.Pixel)
			{
				return PaintAtCursor(texture, ((RaycastHit)(ref hit)).textureCoord, mirrorTarget);
			}
			string fallbackReason = string.Empty;
			if (!TryComputeWorldBrushRadius(hit, texture, out var radius, out fallbackReason))
			{
				radius = EstimateWorldBrushRadius(texture);
			}
			bool num = ShouldApplyMirror(texture, ((RaycastHit)(ref hit)).textureCoord, mirrorTarget);
			HashSet<int> touchedPixels = (num ? new HashSet<int>() : null);
			TextSurfaceStampStats stats;
			string fallbackReason2;
			bool flag = CompositeBrushSurfaceStroke(texture, ((RaycastHit)(ref hit)).point, ((RaycastHit)(ref hit)).normal, radius, mirrored: false, touchedPixels, out stats, out fallbackReason2);
			TextSurfaceStampStats stats2 = default(TextSurfaceStampStats);
			float num2 = radius;
			string fallbackReason3 = string.Empty;
			if (num && TryGetMirrorWorldPlacement(mirrorTarget, out var point, out var normal))
			{
				flag |= CompositeBrushSurfaceStroke(texture, point, normal, num2, mirrored: true, touchedPixels, out stats2, out fallbackReason3);
			}
			string fallbackReason4 = CombineReasons(fallbackReason, fallbackReason2, fallbackReason3);
			if (!flag)
			{
				LogBrushSurfaceStrokeSkipped("surface projection wrote no pixels", texture, hit, mirrorTarget, stats, stats2, radius, num2, fallbackReason4);
				return false;
			}
			texture.Apply(false, false);
			InvalidateDecalPreview("texture changed by surface brush stroke");
			if ((Object)(object)_previewMaterial != (Object)null)
			{
				_previewMaterial.mainTexture = (Texture)(object)texture;
			}
			DrawableSuitsPlugin.Registry.ApplyEditedTexture(_selectedSuitId, _designName, broadcast: false);
			RefreshTexturePanelPreview("PaintWorldSurfaceBrush", forceLog: false);
			if (_mirrorEnabled && !mirrorTarget.Available)
			{
				SetStatus("Mirror target not found; applied primary only.", warn: false);
			}
			if (_tool == EditorTool.Paint)
			{
				AddRecentColorFromBrush("Paint");
			}
			LogBrushSurfaceStrokeApplied(texture, hit, mirrorTarget, stats, stats2, radius, num2, fallbackReason4);
			LogPaintApplied(texture, ((RaycastHit)(ref hit)).textureCoord, mirrorTarget);
			UpdateBrushIndicator();
			return true;
		}

		private bool TryComputeWorldBrushRadius(RaycastHit hit, Texture2D texture, out float radius, out string fallbackReason)
		{
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: 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_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			radius = 0f;
			fallbackReason = string.Empty;
			if ((Object)(object)_worldPaintProxyObject == (Object)null || (Object)(object)_worldPaintMesh == (Object)null || (Object)(object)texture == (Object)null)
			{
				fallbackReason = "world brush dependencies missing";
				return false;
			}
			if (((RaycastHit)(ref hit)).triangleIndex < 0)
			{
				fallbackReason = $"invalid triangle {((RaycastHit)(ref hit)).triangleIndex}";
				return false;
			}
			int[] triangles = _worldPaintMesh.triangles;
			Vector3[] vertices = _worldPaintMesh.vertices;
			Vector2[] uv = _worldPaintMesh.uv;
			int num = ((RaycastHit)(ref hit)).triangleIndex * 3;
			if (triangles == null || vertices == null || uv == null || num < 0 || num + 2 >= triangles.Length)
			{
				fallbackReason = $"triangle array unavailable index={((RaycastHit)(ref hit)).triangleIndex}";
				return false;
			}
			int num2 = triangles[num];
			int num3 = triangles[num + 1];
			int num4 = triangles[num + 2];
			if (num2 < 0 || num3 < 0 || num4 < 0 || num2 >= vertices.Length || num3 >= vertices.Length || num4 >= vertices.Length || num2 >= uv.Length || num3 >= uv.Length || num4 >= uv.Length)
			{
				fallbackReason = $"triangle vertex out of range index={((RaycastHit)(ref hit)).triangleIndex}";
				return false;
			}
			Vector3 val = vertices[num3] - vertices[num2];
			Vector3 val2 = vertices[num4] - vertices[num2];
			Vector2 val3 = uv[num3] - uv[num2];
			Vector2 val4 = uv[num4] - uv[num2];
			float num5 = val3.x * val4.y - val3.y * val4.x;
			if (Mathf.Abs(num5) < 1E-06f)
			{
				fallbackReason = $"degenerate uv triangle {((RaycastHit)(ref hit)).triangleIndex}";
				return false;
			}
			float num6 = 1f / num5;
			Vector3 val5 = (val * val4.y - val2 * val3.y) * num6;
			Vector3 val6 = (val2 * val3.x - val * val4.x) * num6;
			float num7 = EffectiveBrushRadiusPixels();
			float num8 = num7 / Mathf.Max(1f, (float)((Texture)texture).width);
			float num9 = num7 / Mathf.Max(1f, (float)((Texture)texture).height);
			Transform transform = _worldPaintProxyObject.transform;
			Vector3 val7 = transform.TransformVector(val5 * num8);
			float magnitude = ((Vector3)(ref val7)).magnitude;
			val7 = transform.TransformVector(val6 * num9);
			float magnitude2 = ((Vector3)(ref val7)).magnitude;
			float num10 = Mathf.Max(magnitude, magnitude2);
			if (float.IsNaN(num10) || float.IsInfinity(num10) || num10 <= 0.0001f)
			{
				fallbackReason = $"invalid world radius {num10:0.#####}";
				return false;
			}
			float num11;
			if (!((Object)(object)_worldAvatarRenderer != (Object)null))
			{
				num11 = 1.8f;
			}
			else
			{
				Bounds bounds = ((Renderer)_worldAvatarRenderer).bounds;
				num11 = ((Bounds)(ref bounds)).size.y;
			}
			float num12 = num11;
			if (num12 <= 0.01f)
			{
				num12 = 1.8f;
			}
			radius = Mathf.Clamp(num10, num12 * 0.002f, num12 * 0.35f);
			return true;
		}

		private float EstimateWorldBrushRadius(Texture2D texture)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			float num;
			if (!((Object)(object)_worldAvatarRenderer != (Object)null))
			{
				num = 1.8f;
			}
			else
			{
				Bounds bounds = ((Renderer)_worldAvatarRenderer).bounds;
				num = ((Bounds)(ref bounds)).size.y;
			}
			float num2 = num;
			if (num2 <= 0.01f)
			{
				num2 = 1.8f;
			}
			float num3 = (((Object)(object)texture != (Object)null) ? Mathf.Max(1f, (float)Mathf.Max(((Texture)texture).width, ((Texture)texture).height)) : 1024f);
			return Mathf.Clamp(EffectiveBrushRadiusPixels() / num3 * num2, num2 * 0.002f, num2 * 0.28f);
		}

		private bool TryBuildBrushProjectionFrame(Vector3 center, Vector3 normal, float worldRadius, out TextProjectionFrame frame)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: 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_0043: 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_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_00b8: 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_00ba: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: 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_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			frame = default(TextProjectionFrame);
			if ((Object)(object)_worldEditorCamera == (Object)null || worldRadius <= 0.0001f)
			{
				return false;
			}
			if (((Vector3)(ref normal)).sqrMagnitude < 0.0001f)
			{
				normal = -((Component)_worldEditorCamera).transform.forward;
			}
			((Vector3)(ref normal)).Normalize();
			Vector3 right = ((Component)_worldEditorCamera).transform.right;
			Vector3 up = ((Component)_worldEditorCamera).transform.up;
			Vector3 val = Vector3.ProjectOnPlane(right, normal);
			if (((Vector3)(ref val)).sqrMagnitude < 0.0001f)
			{
				val = Vector3.Cross(Vector3.up, normal);
				if (((Vector3)(ref val)).sqrMagnitude < 0.0001f)
				{
					val = Vector3.Cross(Vector3.forward, normal);
				}
			}
			((Vector3)(ref val)).Normalize();
			Vector3 val2 = Vector3.ProjectOnPlane(up, normal);
			val2 -= val * Vector3.Dot(val2, val);
			if (((Vector3)(ref val2)).sqrMagnitude < 0.0001f)
			{
				val2 = Vector3.Cross(val, normal);
				if (((Vector3)(ref val2)).sqrMagnitude < 0.0001f)
				{
					val2 = Vector3.Cross(normal, val);
				}
			}
			if (Vector3.Dot(val2, up) < 0f)
			{
				val2 = -val2;
			}
			((Vector3)(ref val2)).Normalize();
			if (Vector3.Dot(val, right) < 0f)
			{
				val = -val;
			}
			frame = new TextProjectionFrame
			{
				Center = center,
				Normal = normal,
				Right = val,
				Up = val2,
				WorldWidth = worldRadius * 2f,
				WorldHeight = worldRadius * 2f
			};
			return true;
		}

		private bool CompositeBrushSurfaceStroke(Texture2D target, Vector3 center, Vector3 normal, float worldRadius, bool mirrored, HashSet<int> touchedPixels, out TextSurfaceStampStats stats, out string fallbackReason)
		{
			//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_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_050b: Unknown result type (might be due to invalid IL or missing references)
			//IL_051c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0526: Unknown result type (might be due to invalid IL or missing references)
			//IL_0537: Unknown result type (might be due to invalid IL or missing references)
			//IL_0539: Unknown result type (might be due to invalid IL or missing references)
			//IL_0547: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			stats = default(TextSurfaceStampStats);
			stats.Mirrored = mirrored;
			stats.WorldWidth = worldRadius * 2f;
			stats.WorldHeight = worldRadius * 2f;
			fallbackReason = string.Empty;
			if ((Object)(object)target == (Object)null || (Object)(object)_worldPaintCollider == (Object)null || (Object)(object)_worldPaintProxyObject == (Object)null)
			{
				fallbackReason = "surface brush dependencies missing";
				return false;
			}
			Texture2D val = DrawableSuitsPlugin.Registry.GetOrCreateState(_selectedSuitId)?.BaseTexture;
			if (_tool == EditorTool.Erase && (Object)(object)val == (Object)null)
			{
				fallbackReason = "base texture missing";
				return false;
			}
			if (!TryBuildBrushProjectionFrame(center, normal, worldRadius, out var frame))
			{
				fallbackReason = "brush projection frame unavailable";
				return false;
			}
			stats.WorldWidth = frame.WorldWidth;
			stats.WorldHeight = frame.WorldHeight;
			int num = Mathf.Clamp(Mathf.CeilToInt(EffectiveBrushRadiusPixels() * 1.25f), 10, 96);
			int num2 = num + 1;
			int num3 = num + 1;
			SurfaceStampGridSample[] array = new SurfaceStampGridSample[num2 * num3];
			float num4 = Mathf.Max(0.08f, worldRadius * 3f);
			float distance = num4 * 2.5f;
			Dictionary<int, SurfaceStampSample> dictionary = new Dictionary<int, SurfaceStampSample>();
			float brushProjectionSeamThreshold = GetBrushProjectionSeamThreshold(target);
			bool paint = _tool == EditorTool.Paint;
			BrushShapeStats stats2 = new BrushShapeStats
			{
				Available = true,
				Mirrored = mirrored
			};
			for (int i = 0; i < num3; i++)
			{
				float num5 = (float)i / Mathf.Max(1f, (float)num);
				float num6 = (num5 - 0.5f) * frame.WorldHeight;
				for (int j = 0; j < num2; j++)
				{
					float num7 = (float)j / Mathf.Max(1f, (float)num);
					float num8 = (num7 - 0.5f) * frame.WorldWidth;
					stats.ProjectionSamples++;
					int randomSkippedSamples = stats2.RandomSkippedSamples;
					if (!TryEvaluateBrushShape(num8, num6, worldRadius, j - num / 2, i - num / 2, paint, out var alpha, ref stats2))
					{
						if (stats2.RandomSkippedSamples > randomSkippedSamples)
						{
							stats.RandomSkippedSamples++;
							stats.SkippedPixels++;
						}
						continue;
					}
					stats.AcceptedSamples++;
					Vector3 planePoint = frame.Center + frame.Right * num8 + frame.Up * num6;
					if (!TryRaycastSurfaceStampPoint(planePoint, frame.Normal, num4, distance, out var hit))
					{
						stats.OffSuitSamples++;
						stats.SkippedPixels++;
						continue;
					}
					Vector2Int val2 = TexturePixel(target, ((RaycastHit)(ref hit)).textureCoord);
					if (((Vector2Int)(ref val2)).x < 0 || ((Vector2Int)(ref val2)).y < 0 || ((Vector2Int)(ref val2)).x >= ((Texture)target).width || ((Vector2Int)(ref val2)).y >= ((Texture)target).height)
					{
						stats.OffSuitSamples++;
						stats.SkippedPixels++;
						continue;
					}
					SurfaceStampGridSample surfaceStampGridSample = new SurfaceStampGridSample
					{
						Valid = true,
						StampUv = new Vector2(num7, num5),
						SurfaceUv = ((RaycastHit)(ref hit)).textureCoord,
						Pixel = new Vector2(((RaycastHit)(ref hit)).textureCoord.x * (float)(((Texture)target).width - 1), ((RaycastHit)(ref hit)).textureCoord.y * (float)(((Texture)target).height - 1)),
						Alpha = alpha
					};
					array[GridIndex(j, i, num2)] = surfaceStampGridSample;
					stats.SurfaceHits++;
					AddProjectedBrushPixel(target, val, surfaceStampGridSample.Pixel, surfaceStampGridSample.Alpha, dictionary, ref stats);
				}
			}
			if (BrushShapeUsesCoverageRasterization(_brushShape))
			{
				for (int k = 0; k < num; k++)
				{
					for (int l = 0; l < num; l++)
					{
						SurfaceStampGridSample surfaceStampGridSample2 = array[GridIndex(l, k, num2)];
						SurfaceStampGridSample surfaceStampGridSample3 = array[GridIndex(l + 1, k, num2)];
						SurfaceStampGridSample surfaceStampGridSample4 = array[GridIndex(l, k + 1, num2)];
						SurfaceStampGridSample surfaceStampGridSample5 = array[GridIndex(l + 1, k + 1, num2)];
						if (surfaceStampGridSample2.Valid && surfaceStampGridSample3.Valid && surfaceStampGridSample4.Valid && surfaceStampGridSample5.Valid)
						{
							if (CellCrossesProjectionSeam(surfaceStampGridSample2, surfaceStampGridSample3, surfaceStampGridSample4, surfaceStampGridSample5, brushProjectionSeamThreshold))
							{
								stats.SeamSkippedCells++;
								continue;
							}
							stats.RasterizedCells++;
							RasterizeProjectedBrushTriangle(target, val, surfaceStampGridSample2, surfaceStampGridSample3, surfaceStampGridSample4, dictionary, ref stats);
							RasterizeProjectedBrushTriangle(target, val, surfaceStampGridSample3, surfaceStampGridSample5, surfaceStampGridSample4, dictionary, ref stats);
						}
					}
				}
			}
			Color val3 = default(Color);
			foreach (KeyValuePair<int, SurfaceStampSample> item in dictionary)
			{
				int num9 = item.Key % ((Texture)target).width;
				int num10 = item.Key / ((Texture)target).width;
				if (TryMarkTouchedPixel(target, num9, num10, touchedPixels))
				{
					Color pixel = target.GetPixel(num9, num10);
					((Color)(ref val3))..ctor(item.Value.Color.r, item.Value.Color.g, item.Value.Color.b, pixel.a);
					target.SetPixel(num9, num10, Color.Lerp(pixel, val3, item.Value.Alpha));
					stats.WrittenPixels++;
				}
			}
			LogBrushProjectionCoverageWarning(stats, mirrored, num, brushProjectionSeamThreshold);
			return stats.WrittenPixels > 0;
		}

		private static float GetBrushProjectionSeamThreshold(Texture2D target)
		{
			if ((Object)(object)target == (Object)null)
			{
				return 20f;
			}
			return Mathf.Clamp((float)Mathf.Max(((Texture)target).width, ((Texture)target).height) / 36f, 16f, 56f);
		}

		private void RasterizeProjectedBrushTriangle(Texture2D target, Texture2D baseTexture, SurfaceStampGridSample a, SurfaceStampGridSample b, SurfaceStampGridSample c, Dictionary<int, SurfaceStampSample> projectedSamples, ref TextSurfaceStampStats stats)
		{
			//IL_0002: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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_0087: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Max(0, Mathf.FloorToInt(Mathf.Min(a.Pixel.x, Mathf.Min(b.Pixel.x, c.Pixel.x))));
			int num2 = Mathf.Min(((Texture)target).width - 1, Mathf.CeilToInt(Mathf.Max(a.Pixel.x, Mathf.Max(b.Pixel.x, c.Pixel.x))));
			int num3 = Mathf.Max(0, Mathf.FloorToInt(Mathf.Min(a.Pixel.y, Mathf.Min(b.Pixel.y, c.Pixel.y))));
			int num4 = Mathf.Min(((Texture)target).height - 1, Mathf.CeilToInt(Mathf.Max(a.Pixel.y, Mathf.Max(b.Pixel.y, c.Pixel.y))));
			if (num2 < num || num4 < num3)
			{
				return;
			}
			for (int i = num3; i <= num4; i++)
			{
				for (int j = num; j <= num2; j++)
				{
					if (TryBarycentric2D(new Vector2((float)j + 0.5f, (float)i + 0.5f), a.Pixel, b.Pixel, c.Pixel, out var barycentric, 0.001f))
					{
						float alpha = a.Alpha * barycentric.x + b.Alpha * barycentric.y + c.Alpha * barycentric.z;
						AddProjectedBrushPixel(target, baseTexture, new Vector2((float)j, (float)i), alpha, projectedSamples, ref stats);
					}
				}
			}
		}

		private void AddProjectedBrushPixel(Texture2D target, Texture2D baseTexture, Vector2 pixel, float alpha, Dictionary<int, SurfaceStampSample> projectedSamples, ref TextSurfaceStampStats stats)
		{
			//IL_0017: 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_005e: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null || projectedSamples == null || alpha <= 0.001f)
			{
				return;
			}
			int num = Mathf.Clamp(Mathf.RoundToInt(pixel.x), 0, ((Texture)target).width - 1);
			int num2 = Mathf.Clamp(Mathf.RoundToInt(pixel.y), 0, ((Texture)target).height - 1);
			Color color = ((_tool == EditorTool.Erase && (Object)(object)baseTexture != (Object)null) ? baseTexture.GetPixel(num, num2) : _brushColor);
			int key = num2 * ((Texture)target).width + num;
			float num3 = Mathf.Clamp01(alpha);
			SurfaceStampSample value = new SurfaceStampSample
			{
				Color = color,
				Alpha = num3
			};
			stats.AlphaPixels++;
			if (projectedSamples.TryGetValue(key, out var value2))
			{
				if (num3 > value2.Alpha)
				{
					projectedSamples[key] = value;
				}
			}
			else
			{
				projectedSamples[key] = value;
			}
		}

		private void LogBrushProjectionCoverageWarning(TextSurfaceStampStats stats, bool mirrored, int sampleDiameter, float seamThreshold)
		{
			int num = stats.RasterizedCells + stats.SeamSkippedCells;
			if (stats.SeamSkippedCells >= 6 && num > 0 && !((float)stats.SeamSkippedCells < (float)num * 0.12f))
			{
				string text = $"tool={_tool}|shape={_brushShape}|mirrored={mirrored}|sample={sampleDiameter}|seam={stats.SeamSkippedCells}|cells={stats.RasterizedCells}|threshold={Mathf.RoundToInt(seamThreshold)}|brush={Mathf.RoundToInt(EffectiveBrushRadiusPixels())}";
				if (!(Time.unscaledTime - _lastBrushSurfaceWarningTime < 2f) || !string.Equals(text, _lastBrushSurfaceWarningKey, StringComparison.Ordinal))
				{
					_lastBrushSurfaceWarningTime = Time.unscaledTime;
					_lastBrushSurfaceWarningKey = text;
					DrawableSuitsDiagnostics.Warn($"BrushSurfaceProjectionWarning: {text}; projectionSamples={stats.ProjectionSamples}; surfaceHits={stats.SurfaceHits}; offSuit={stats.OffSuitSamples}; written={stats.WrittenPixels}; skipped={stats.SkippedPixels}; pointerSource={_pointerSource}");
				}
			}
		}

		private bool ApplyDirectBrush(Texture2D texture, Vector2 uv, bool mirrored, HashSet<int> touchedPixels, out BrushShapeStats stats)
		{
			//IL_0054: 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)
			stats = default(BrushShapeStats);
			stats.Available = true;
			stats.Mirrored = mirrored;
			if ((Object)(object)texture == (Object)null)
			{
				return false;
			}
			Texture2D val = DrawableSuitsPlugin.Registry.GetOrCreateState(_selectedSuitId)?.BaseTexture;
			if (_tool == EditorTool.Erase && (Object)(object)val == (Object)null)
			{
				return false;
			}
			int num = Mathf.RoundToInt(uv.x * (float)(((Texture)texture).width - 1));
			int num2 = Mathf.RoundToInt(uv.y * (float)(((Texture)texture).height - 1));
			if (num < 0 || num2 < 0 || num >= ((Texture)texture).width || num2 >= ((Texture)texture).height)
			{
				return false;
			}
			if (_brushShape == BrushShape.Pixel)
			{
				stats.CheckedSamples = 1;
				stats.AcceptedSamples = 1;
				return ApplyDirectBrushPixel(texture, val, num, num2, 1f, touchedPixels, ref stats);
			}
			float num3 = Mathf.Max(1f, EffectiveBrushRadiusPixels());
			int num4 = Mathf.CeilToInt(num3);
			int num5 = Mathf.Max(0, num - num4);
			int num6 = Mathf.Min(((Texture)texture).width - 1, num + num4);
			int num7 = Mathf.Max(0, num2 - num4);
			int num8 = Mathf.Min(((Texture)texture).height - 1, num2 + num4);
			bool flag = false;
			for (int i = num7; i <= num8; i++)
			{
				for (int j = num5; j <= num6; j++)
				{
					int num9 = j - num;
					int num10 = i - num2;
					if (TryEvaluateBrushShape(num9, num10, num3, num9, num10, _tool == EditorTool.Paint, out var alpha, ref stats))
					{
						flag |= ApplyDirectBrushPixel(texture, val, j, i, alpha, touchedPixels, ref stats);
					}
				}
			}
			return flag;
		}

		private bool ApplyDirectBrushPixel(Texture2D texture, Texture2D baseTexture, int x, int y, float alpha, HashSet<int> touchedPixels, ref BrushShapeStats stats)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)texture == (Object)null || alpha <= 0.001f || x < 0 || y < 0 || x >= ((Texture)texture).width || y >= ((Texture)texture).height)
			{
				return false;
			}
			if (!TryMarkTouchedPixel(texture, x, y, touchedPixels))
			{
				return false;
			}
			Color pixel = texture.GetPixel(x, y);
			Color val = ((_tool == EditorTool.Erase && (Object)(object)baseTexture != (Object)null) ? baseTexture.GetPixel(x, y) : _brushColor);
			texture.SetPixel(x, y, Color.Lerp(pixel, val, Mathf.Clamp01(alpha)));
			stats.WrittenPixels++;
			return true;
		}

		private bool TryEvaluateBrushShape(float x, float y, float radius, int sampleX, int sampleY, bool paint, out float alpha, ref BrushShapeStats stats)
		{
			stats.CheckedSamples++;
			alpha = 0f;
			radius = Mathf.Max(0.0001f, radius);
			float num = Mathf.Abs(x);
			float num2 = Mathf.Abs(y);
			float num3 = Mathf.Sqrt(x * x + y * y) / radius;
			float num4 = Mathf.Clamp01(_brushOpacity);
			switch (_brushShape)
			{
			case BrushShape.Square:
				if (num > radius || num2 > radius)
				{
					return false;
				}
				alpha = num4;
				stats.AcceptedSamples++;
				return true;
			case BrushShape.SoftAirbrush:
				if (num3 > 1f)
				{
					return false;
				}
				alpha = (paint ? (num4 * Mathf.Pow(Mathf.Clamp01(1f - num3), 2f)) : num4);
				stats.AcceptedSamples++;
				return alpha > 0.001f;
			case BrushShape.SprayPaint:
				if (num3 > 1f)
				{
					return false;
				}
				if (BrushRandom01(_brushStrokeSeed, sampleX, sampleY, 17) > Mathf.Lerp(0.36f, 0.12f, Mathf.Clamp01(num3)))
				{
					stats.RandomSkippedSamples++;
					return false;
				}
				alpha = (paint ? (num4 * Mathf.Lerp(0.5f, 1f, BrushRandom01(_brushStrokeSeed, sampleX, sampleY, 23))) : num4);
				stats.AcceptedSamples++;
				return true;
			case BrushShape.NoiseScatter:
				if (num3 > 1f)
				{
					return false;
				}
				if (BrushRandom01(_brushStrokeSeed, sampleX, sampleY, 31) > 0.58f)
				{
					stats.RandomSkippedSamples++;
					return false;
				}
				alpha = (paint ? (num4 * Mathf.Lerp(0.35f, 1f, BrushRandom01(_brushStrokeSeed, sampleX, sampleY, 43))) : num4);
				stats.AcceptedSamples++;
				return true;
			case BrushShape.Pixel:
				if (num > 0.5f || num2 > 0.5f)
				{
					return false;
				}
				alpha = num4;
				stats.AcceptedSamples++;
				return true;
			default:
				if (num3 > 1f)
				{
					return false;
				}
				alpha = (paint ? (num4 * Mathf.Clamp01(1f - num3 + 0.25f)) : num4);
				stats.AcceptedSamples++;
				return true;
			}
		}

		private static float BrushRandom01(int seed, int x, int y, int salt)
		{
			int num = seed ^ (x * 73856093) ^ (y * 19349663) ^ (salt * 83492791);
			int num2 = (num ^ (num >>> 13)) * 1274126177;
			return (float)(uint)((num2 ^ (num2 >>> 16)) & 0xFFFFFF) / 16777215f;
		}

		private float EffectiveBrushRadiusPixels()
		{
			if (_brushShape != BrushShape.Pixel)
			{
				return Mathf.Max(1f, _brushSize);
			}
			return 0.5f;
		}

		private static bool BrushShapeUsesCoverageRasterization(BrushShape shape)
		{
			if (shape != BrushShape.Circle && shape != BrushShape.Square)
			{
				return shape == BrushShape.SoftAirbrush;
			}
			return true;
		}

		private bool PaintCircle(Texture2D texture, Vector2 uv, Color color, float radius, float opacity, HashSet<int> touchedPixels = null)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.RoundToInt(uv.x * (float)(((Texture)texture).width - 1));
			int num2 = Mathf.RoundToInt(uv.y * (float)(((Texture)texture).height - 1));
			int num3 = Mathf.RoundToInt(radius);
			int num4 = num3 * num3;
			int num5 = Mathf.Max(0, num - num3);
			int num6 = Mathf.Min(((Texture)texture).width - 1, num + num3);
			int num7 = Mathf.Max(0, num2 - num3);
			int num8 = Mathf.Min(((Texture)texture).height - 1, num2 + num3);
			bool result = false;
			for (int i = num7; i <= num8; i++)
			{
				for (int j = num5; j <= num6; j++)
				{
					int num9 = j - num;
					int num10 = i - num2;
					if (num9 * num9 + num10 * num10 <= num4 && TryMarkTouchedPixel(texture, j, i, touchedPixels))
					{
						float num11 = 1f - Mathf.Sqrt((float)(num9 * num9 + num10 * num10)) / Mathf.Max(1f, (float)num3);
						Color pixel = texture.GetPixel(j, i);
						texture.SetPixel(j, i, Color.Lerp(pixel, color, opacity * Mathf.Clamp01(num11 + 0.25f)));
						result = true;
					}
				}
			}
			return result;
		}

		private bool EraseCircle(Texture2D texture, Vector2 uv, float radius, float opacity, HashSet<int> touchedPixels = null)
		{
			//IL_0027: 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_00cd: 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_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: 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_00f0: Unknown result type (might be due to invalid IL or missing references)
			SuitTextureState orCreateState = DrawableSuitsPlugin.Registry.GetOrCreateState(_selectedSuitId);
			if ((Object)(object)orCreateState?.BaseTexture == (Object)null)
			{
				return false;
			}
			int num = Mathf.RoundToInt(uv.x * (float)(((Texture)texture).width - 1));
			int num2 = Mathf.RoundToInt(uv.y * (float)(((Texture)texture).height - 1));
			int num3 = Mathf.RoundToInt(radius);
			int num4 = num3 * num3;
			int num5 = Mathf.Max(0, num - num3);
			int num6 = Mathf.Min(((Texture)texture).width - 1, num + num3);
			int num7 = Mathf.Max(0, num2 - num3);
			int num8 = Mathf.Min(((Texture)texture).height - 1, num2 + num3);
			bool result = false;
			for (int i = num7; i <= num8; i++)
			{
				for (int j = num5; j <= num6; j++)
				{
					int num9 = j - num;
					int num10 = i - num2;
					if (num9 * num9 + num10 * num10 <= num4 && TryMarkTouchedPixel(texture, j, i, touchedPixels))
					{
						Color pixel = texture.GetPixel(j, i);
						Color pixel2 = orCreateState.BaseTexture.GetPixel(j, i);
						texture.SetPixel(j, i, Color.Lerp(pixel, pixel2, opacity));
						result = true;
					}
				}
			}
			return result;
		}

		private bool ApplyDecal(Texture2D target, Vector2 uv, bool mirrored = false, HashSet<int> touchedPixels = null)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetActivePlacementStamp(out var stampTexture, out var failureReason))
			{
				WarnMissingDecal("ApplyDecal");
				if (!string.IsNullOrWhiteSpace(failureReason))
				{
					DrawableSuitsDiagnostics.Info($"DecalStampSkipped: mode=ApplyDecal; reason={failureReason}; decal={CurrentDecalName()}; suit={_selectedSuitId}");
				}
				return false;
			}
			return CompositePlacementStamp(target, stampTexture, uv, _decalSize, CurrentVisiblePlacementRotation(mirrored), _brushOpacity, mirrored, touchedPixels);
		}

		private bool ApplyTextStamp(Texture2D target, Vector2 uv, bool mirrored = false, HashSet<int> touchedPixels = null)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetTextStampTexture(out var texture, out var failureReason))
			{
				LogTextStampSkipped("ApplyTextStamp", failureReason);
				return false;
			}
			return CompositePlacementStamp(target, texture, uv, _textSize, CurrentVisiblePlacementRotation(mirrored), _brushOpacity, mirrored, touchedPixels, tintWithBrushColor: true);
		}

		private bool ApplyStickerStamp(Texture2D target, Vector2 uv, bool mirrored = false, HashSet<int> touchedPixels = null)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetActivePlacementStamp(out var stampTexture, out var failureReason))
			{
				LogStickerStampSkipped("ApplyStickerStamp", failureReason);
				return false;
			}
			return CompositePlacementStamp(target, stampTexture, uv, _stickerSize, CurrentVisiblePlacementRotation(mirrored), _brushOpacity, mirrored, touchedPixels);
		}

		private float CurrentVisiblePlacementRotation(bool mirrored)
		{
			if (!mirrored)
			{
				return CurrentPlacementRotation();
			}
			return 0f - CurrentPlacementRotation();
		}

		private bool CompositeTextSurfaceStamp(Texture2D target, Texture2D stamp, Vector3 center, Vector3 normal, float rotation, bool mirrored, float opacity, HashSet<int> touchedPixels, out TextSurfaceStampStats stats)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			return CompositeSurfaceStamp(target, stamp, center, normal, rotation, CalculateTextWorldHeight(), mirrored, opacity, touchedPixels, tintWithBrushColor: true, out stats);
		}

		private bool CompositeDecalSurfaceStamp(Texture2D target, Texture2D stamp, Vector3 center, Vector3 normal, float rotation, bool mirrored, float opacity, HashSet<int> touchedPixels, out TextSurfaceStampStats stats, bool tintWithBrushColor = false)
		{
			//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)
			int num = Mathf.Clamp(Mathf.RoundToInt((_tool == EditorTool.Sticker) ? _stickerSize : _decalSize), 12, 160);
			float num2 = (((Object)(object)stamp != (Object)null) ? ((float)((Texture)stamp).width / Mathf.Max(1f, (float)((Texture)stamp).height)) : 1f);
			int sampleWidth = Mathf.Clamp(Mathf.RoundToInt((float)num * num2), 12, 256);
			float worldHeight = ((_tool == EditorTool.Sticker) ? CalculateStickerWorldHeight() : CalculateDecalWorldHeight());
			return CompositeDecalSurfaceCoverageStamp(target, stamp, center, normal, rotation, worldHeight, mirrored, opacity, touchedPixels, sampleWidth, num, out stats, tintWithBrushColor);
		}

		private bool CompositeDecalSurfaceCoverageStamp(Texture2D target, Texture2D stamp, Vector3 center, Vector3 normal, float rotation, float worldHeight, bool mirrored, float opacity, HashSet<int> touchedPixels, int sampleWidth, int sampleHeight, out TextSurfaceStampStats stats, bool tintWithBrushColor = false)
		{
			//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_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: 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_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: 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_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0420: Unknown result type (might be due to invalid IL or missing references)
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Unknown result type (might be due to invalid IL or missing references)
			//IL_0441: Unknown result type (might be due to invalid IL or missing references)
			//IL_0452: Unknown result type (might be due to invalid IL or missing references)
			//IL_045c: Unknown result type (might be due to invalid IL or missing references)
			//IL_046d: Unknown result type (might be due to invalid IL or missing references)
			//IL_046f: Unknown result type (might be due to invalid IL or missing references)
			//IL_047d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			stats = default(TextSurfaceStampStats);
			stats.Mirrored = mirrored;
			if ((Object)(object)target == (Object)null || (Object)(object)stamp == (Object)null || (Object)(object)_worldPaintCollider == (Object)null || (Object)(object)_worldPaintProxyObject == (Object)null)
			{
				return false;
			}
			if (!TryBuildProjectionFrame(center, normal, rotation, stamp, worldHeight, mirrored, out var frame))
			{
				stats.SkippedPixels = Mathf.Max(1, sampleWidth) * Mathf.Max(1, sampleHeight);
				return false;
			}
			stats.WorldWidth = frame.WorldWidth;
			stats.WorldHeight = frame.WorldHeight;
			int num = Mathf.Max(2, sampleWidth + 1);
			int num2 = Mathf.Max(2, sampleHeight + 1);
			SurfaceStampGridSample[] array = new SurfaceStampGridSample[num * num2];
			float num3 = Mathf.Max(0.08f, frame.WorldHeight * 2.5f);
			float distance = num3 * 2.5f;
			Dictionary<int, SurfaceStampSample> dictionary = new Dictionary<int, SurfaceStampSample>();
			float decalProjectionSeamThreshold = GetDecalProjectionSeamThreshold(target);
			float opacity2 = Mathf.Clamp01(opacity);
			for (int i = 0; i < num2; i++)
			{
				float num4 = (float)i / Mathf.Max(1f, (float)sampleHeight);
				float num5 = (num4 - 0.5f) * frame.WorldHeight;
				for (int j = 0; j < num; j++)
				{
					float num6 = (float)j / Mathf.Max(1f, (float)sampleWidth);
					float num7 = (mirrored ? (1f - num6) : num6);
					Vector3 planePoint = frame.Center + frame.Right * ((num6 - 0.5f) * frame.WorldWidth) + frame.Up * num5;
					stats.ProjectionSamples++;
					if (!TryRaycastSurfaceStampPoint(planePoint, frame.Normal, num3, distance, out var hit))
					{
						stats.OffSuitSamples++;
						stats.SkippedPixels++;
						continue;
					}
					Vector2Int val = TexturePixel(target, ((RaycastHit)(ref hit)).textureCoord);
					if (((Vector2Int)(ref val)).x < 0 || ((Vector2Int)(ref val)).y < 0 || ((Vector2Int)(ref val)).x >= ((Texture)target).width || ((Vector2Int)(ref val)).y >= ((Texture)target).height)
					{
						stats.OffSuitSamples++;
						stats.SkippedPixels++;
						continue;
					}
					SurfaceStampGridSample surfaceStampGridSample = new SurfaceStampGridSample
					{
						Valid = true,
						StampUv = new Vector2(Mathf.Clamp01(num7), Mathf.Clamp01(num4)),
						SurfaceUv = ((RaycastHit)(ref hit)).textureCoord,
						Pixel = new Vector2(((RaycastHit)(ref hit)).textureCoord.x * (float)(((Texture)target).width - 1), ((RaycastHit)(ref hit)).textureCoord.y * (float)(((Texture)target).height - 1))
					};
					array[GridIndex(j, i, num)] = surfaceStampGridSample;
					stats.SurfaceHits++;
					AddProjectedStampPixel(target, stamp, surfaceStampGridSample.StampUv, surfaceStampGridSample.Pixel, opacity2, dictionary, ref stats, tintWithBrushColor);
				}
			}
			for (int k = 0; k < sampleHeight; k++)
			{
				for (int l = 0; l < sampleWidth; l++)
				{
					SurfaceStampGridSample surfaceStampGridSample2 = array[GridIndex(l, k, num)];
					SurfaceStampGridSample surfaceStampGridSample3 = array[GridIndex(l + 1, k, num)];
					SurfaceStampGridSample surfaceStampGridSample4 = array[GridIndex(l, k + 1, num)];
					SurfaceStampGridSample surfaceStampGridSample5 = array[GridIndex(l + 1, k + 1, num)];
					if (surfaceStampGridSample2.Valid && surfaceStampGridSample3.Valid && surfaceStampGridSample4.Valid && surfaceStampGridSample5.Valid)
					{
						if (CellCrossesProjectionSeam(surfaceStampGridSample2, surfaceStampGridSample3, surfaceStampGridSample4, surfaceStampGridSample5, decalProjectionSeamThreshold))
						{
							stats.SeamSkippedCells++;
							continue;
						}
						stats.RasterizedCells++;
						RasterizeProjectedDecalTriangle(target, stamp, surfaceStampGridSample2, surfaceStampGridSample3, surfaceStampGridSample4, opacity2, dictionary, ref stats, tintWithBrushColor);
						RasterizeProjectedDecalTriangle(target, stamp, surfaceStampGridSample3, surfaceStampGridSample5, surfaceStampGridSample4, opacity2, dictionary, ref stats, tintWithBrushColor);
					}
				}
			}
			Color val2 = default(Color);
			foreach (KeyValuePair<int, SurfaceStampSample> item in dictionary)
			{
				int num8 = item.Key % ((Texture)target).width;
				int num9 = item.Key / ((Texture)target).width;
				if (TryMarkTouchedPixel(target, num8, num9, touchedPixels))
				{
					Color pixel = target.GetPixel(num8, num9);
					((Color)(ref val2))..ctor(item.Value.Color.r, item.Value.Color.g, item.Value.Color.b, pixel.a);
					target.SetPixel(num8, num9, Color.Lerp(pixel, val2, item.Value.Alpha));
					stats.WrittenPixels++;
				}
			}
			LogDecalProjectionCoverageWarning(stats, mirrored, sampleWidth, sampleHeight, decalProjectionSeamThreshold);
			return stats.WrittenPixels > 0;
		}

		private static int GridIndex(int x, int y, int width)
		{
			return y * width + x;
		}

		private static float GetDecalProjectionSeamThreshold(Texture2D target)
		{
			if ((Object)(object)target == (Object)null)
			{
				return 24f;
			}
			return Mathf.Clamp((float)Mathf.Max(((Texture)target).width, ((Texture)target).height) / 32f, 18f, 64f);
		}

		private static bool CellCrossesProjectionSeam(SurfaceStampGridSample s00, SurfaceStampGridSample s10, SurfaceStampGridSample s01, SurfaceStampGridSample s11, float seamThreshold)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_003e: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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_007a: 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)
			float num = Mathf.Max(1f, seamThreshold);
			float num2 = num * 1.75f;
			if (!(Vector2.Distance(s00.Pixel, s10.Pixel) > num) && !(Vector2.Distance(s10.Pixel, s11.Pixel) > num) && !(Vector2.Distance(s11.Pixel, s01.Pixel) > num) && !(Vector2.Distance(s01.Pixel, s00.Pixel) > num) && !(Vector2.Distance(s00.Pixel, s11.Pixel) > num2))
			{
				return Vector2.Distance(s10.Pixel, s01.Pixel) > num2;
			}
			return true;
		}

		private void RasterizeProjectedDecalTriangle(Texture2D target, Texture2D stamp, SurfaceStampGridSample a, SurfaceStampGridSample b, SurfaceStampGridSample c, float opacity, Dictionary<int, SurfaceStampSample> projectedSamples, ref TextSurfaceStampStats stats, bool tintWithBrushColor)
		{
			//IL_0002: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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_0087: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: 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_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Max(0, Mathf.FloorToInt(Mathf.Min(a.Pixel.x, Mathf.Min(b.Pixel.x, c.Pixel.x))));
			int num2 = Mathf.Min(((Texture)target).width - 1, Mathf.CeilToInt(Mathf.Max(a.Pixel.x, Mathf.Max(b.Pixel.x, c.Pixel.x))));
			int num3 = Mathf.Max(0, Mathf.FloorToInt(Mathf.Min(a.Pixel.y, Mathf.Min(b.Pixel.y, c.Pixel.y))));
			int num4 = Mathf.Min(((Texture)target).height - 1, Mathf.CeilToInt(Mathf.Max(a.Pixel.y, Mathf.Max(b.Pixel.y, c.Pixel.y))));
			if (num2 < num || num4 < num3)
			{
				return;
			}
			for (int i = num3; i <= num4; i++)
			{
				for (int j = num; j <= num2; j++)
				{
					if (TryBarycentric2D(new Vector2((float)j + 0.5f, (float)i + 0.5f), a.Pixel, b.Pixel, c.Pixel, out var barycentric, 0.001f))
					{
						Vector2 stampUv = a.StampUv * barycentric.x + b.StampUv * barycentric.y + c.StampUv * barycentric.z;
						AddProjectedStampPixel(target, stamp, stampUv, new Vector2((float)j, (float)i), opacity, projectedSamples, ref stats, tintWithBrushColor);
					}
				}
			}
		}

		private void AddProjectedStampPixel(Texture2D target, Texture2D stamp, Vector2 stampUv, Vector2 pixel, float opacity, Dictionary<int, SurfaceStampSample> projectedSamples, ref TextSurfaceStampStats stats, bool tintWithBrushColor)
		{
			//IL_0017: 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_004e: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_00d6: 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_00db: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null || (Object)(object)stamp == (Object)null || projectedSamples == null)
			{
				return;
			}
			int num = Mathf.Clamp(Mathf.RoundToInt(pixel.x), 0, ((Texture)target).width - 1);
			int num2 = Mathf.Clamp(Mathf.RoundToInt(pixel.y), 0, ((Texture)target).height - 1);
			Color pixelBilinear = stamp.GetPixelBilinear(Mathf.Clamp01(stampUv.x), Mathf.Clamp01(stampUv.y));
			if (pixelBilinear.a <= 0.01f)
			{
				return;
			}
			stats.AlphaPixels++;
			float num3 = pixelBilinear.a * Mathf.Clamp01(opacity);
			int key = num2 * ((Texture)target).width + num;
			SurfaceStampSample value = new SurfaceStampSample
			{
				Color = (Color)(tintWithBrushColor ? new Color(_brushColor.r, _brushColor.g, _brushColor.b, 1f) : pixelBilinear),
				Alpha = num3
			};
			if (projectedSamples.TryGetValue(key, out var value2))
			{
				if (num3 > value2.Alpha)
				{
					projectedSamples[key] = value;
				}
			}
			else
			{
				projectedSamples[key] = value;
			}
		}

		private void LogDecalProjectionCoverageWarning(TextSurfaceStampStats stats, bool mirrored, int sampleWidth, int sampleHeight, float seamThreshold)
		{
			int num = stats.RasterizedCells + stats.SeamSkippedCells;
			if (stats.SeamSkippedCells >= 6 && num > 0 && !((float)stats.SeamSkippedCells < (float)num * 0.12f))
			{
				string text = $"mirrored={mirrored}|sample={sampleWidth}x{sampleHeight}|seam={stats.SeamSkippedCells}|cells={stats.RasterizedCells}|threshold={Mathf.RoundToInt(seamThreshold)}|decal={CurrentDecalName()}";
				if (!(Time.unscaledTime - _lastDecalCoverageWarningTime < 2f) || !string.Equals(text, _lastDecalCoverageWarningKey, StringComparison.Ordinal))
				{
					_lastDecalCoverageWarningTime = Time.unscaledTime;
					_lastDecalCoverageWarningKey = text;
					DrawableSuitsDiagnostics.Warn($"DecalProjectionCoverageWarning: {text}; projectionSamples={stats.ProjectionSamples}; surfaceHits={stats.SurfaceHits}; offSuit={stats.OffSuitSamples}; written={stats.WrittenPixels}; skipped={stats.SkippedPixels}; pointerSource={_pointerSource}");
				}
			}
		}

		private bool CompositeSurfaceStamp(Texture2D target, Texture2D stamp, Vector3 center, Vector3 normal, float rotation, float worldHeight, bool mirrored, float opacity, HashSet<int> touchedPixels, bool tintWithBrushColor, out TextSurfaceStampStats stats, int sampleWidth = 0, int sampleHeight = 0)
		{
			//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_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_039b: Unknown result type (might be due to invalid IL or missing references)
			//IL_039d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			stats = default(TextSurfaceStampStats);
			stats.Mirrored = mirrored;
			if ((Object)(object)target == (Object)null || (Object)(object)stamp == (Object)null || (Object)(object)_worldPaintCollider == (Object)null || (Object)(object)_worldPaintProxyObject == (Object)null)
			{
				return false;
			}
			if (!TryBuildProjectionFrame(center, normal, rotation, stamp, worldHeight, mirrored, out var frame))
			{
				stats.SkippedPixels = Mathf.Max(1, (sampleWidth > 0) ? sampleWidth : ((Texture)stamp).width) * Mathf.Max(1, (sampleHeight > 0) ? sampleHeight : ((Texture)stamp).height);
				return false;
			}
			stats.WorldWidth = frame.WorldWidth;
			stats.WorldHeight = frame.WorldHeight;
			Dictionary<int, SurfaceStampSample> dictionary = new Dictionary<int, SurfaceStampSample>();
			float num = Mathf.Max(0.08f, frame.WorldHeight * 2.5f);
			float distance = num * 2.5f;
			int num2 = Mathf.Max(1, (sampleWidth > 0) ? sampleWidth : ((Texture)stamp).width);
			int num3 = Mathf.Max(1, (sampleHeight > 0) ? sampleHeight : ((Texture)stamp).height);
			for (int i = 0; i < num3; i++)
			{
				float num4 = ((float)i + 0.5f) / Mathf.Max(1f, (float)num3);
				float num5 = (num4 - 0.5f) * frame.WorldHeight;
				for (int j = 0; j < num2; j++)
				{
					float num6 = ((float)j + 0.5f) / Mathf.Max(1f, (float)num2);
					float num7 = (mirrored ? (1f - num6) : num6);
					Color pixelBilinear = stamp.GetPixelBilinear(Mathf.Clamp01(num7), Mathf.Clamp01(num4));
					if (pixelBilinear.a <= 0.01f)
					{
						continue;
					}
					stats.AlphaPixels++;
					float num8 = (num6 - 0.5f) * frame.WorldWidth;
					Vector3 planePoint = frame.Center + frame.Right * num8 + frame.Up * num5;
					if (!TryRaycastSurfaceStampPoint(planePoint, frame.Normal, num, distance, out var hit))
					{
						stats.SkippedPixels++;
						continue;
					}
					Vector2Int val = TexturePixel(target, ((RaycastHit)(ref hit)).textureCoord);
					if (((Vector2Int)(ref val)).x < 0 || ((Vector2Int)(ref val)).y < 0 || ((Vector2Int)(ref val)).x >= ((Texture)target).width || ((Vector2Int)(ref val)).y >= ((Texture)target).height)
					{
						stats.SkippedPixels++;
						continue;
					}
					int key = ((Vector2Int)(ref val)).y * ((Texture)target).width + ((Vector2Int)(ref val)).x;
					float num9 = pixelBilinear.a * Mathf.Clamp01(opacity);
					SurfaceStampSample value = new SurfaceStampSample
					{
						Color = (Color)(tintWithBrushColor ? new Color(_brushColor.r, _brushColor.g, _brushColor.b, 1f) : pixelBilinear),
						Alpha = num9
					};
					if (dictionary.TryGetValue(key, out var value2))
					{
						if (num9 > value2.Alpha)
						{
							dictionary[key] = value;
						}
					}
					else
					{
						dictionary[key] = value;
					}
				}
			}
			Color val2 = default(Color);
			foreach (KeyValuePair<int, SurfaceStampSample> item in dictionary)
			{
				int num10 = item.Key % ((Texture)target).width;
				int num11 = item.Key / ((Texture)target).width;
				if (TryMarkTouchedPixel(target, num10, num11, touchedPixels))
				{
					Color pixel = target.GetPixel(num10, num11);
					((Color)(ref val2))..ctor(item.Value.Color.r, item.Value.Color.g, item.Value.Color.b, pixel.a);
					target.SetPixel(num10, num11, Color.Lerp(pixel, val2, item.Value.Alpha));
					stats.WrittenPixels++;
				}
			}
			return stats.WrittenPixels > 0;
		}

		private bool TryBuildProjectionFrame(Vector3 center, Vector3 normal, float rotation, Texture2D stamp, float worldHeight, bool mirrored, out TextProjectionFrame frame)
		{
			//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_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_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_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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_00b8: 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_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_00c0: 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_00c2: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: 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_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			frame = default(TextProjectionFrame);
			if ((Object)(object)stamp == (Object)null || (Object)(object)_worldEditorCamera == (Object)null)
			{
				return false;
			}
			if (((Vector3)(ref normal)).sqrMagnitude < 0.0001f)
			{
				normal = ((Component)_worldEditorCamera).transform.forward * -1f;
			}
			((Vector3)(ref normal)).Normalize();
			Vector3 right = ((Component)_worldEditorCamera).transform.right;
			Vector3 up = ((Component)_worldEditorCamera).transform.up;
			Vector3 val = Vector3.ProjectOnPlane(right, normal);
			if (((Vector3)(ref val)).sqrMagnitude < 0.0001f)
			{
				val = Vector3.Cross(Vector3.up, normal);
				if (((Vector3)(ref val)).sqrMagnitude < 0.0001f)
				{
					val = Vector3.Cross(Vector3.forward, normal);
				}
			}
			((Vector3)(ref val)).Normalize();
			Vector3 val2 = Vector3.ProjectOnPlane(up, normal);
			val2 -= val * Vector3.Dot(val2, val);
			if (((Vector3)(ref val2)).sqrMagnitude < 0.0001f)
			{
				val2 = Vector3.Cross(val, normal);
				if (((Vector3)(ref val2)).sqrMagnitude < 0.0001f)
				{
					val2 = Vector3.Cross(normal, val);
				}
			}
			if (Vector3.Dot(val2, up) < 0f)
			{
				val2 = -val2;
			}
			((Vector3)(ref val2)).Normalize();
			if (Vector3.Dot(val, right) < 0f)
			{
				val = -val;
			}
			Quaternion val3 = Quaternion.AngleAxis(rotation, normal);
			val = val3 * val;
			val2 = val3 * val2;
			float num = (float)((Texture)stamp).width / Mathf.Max(1f, (float)((Texture)stamp).height);
			frame = new TextProjectionFrame
			{
				Center = center,
				Normal = normal,
				Right = val,
				Up = val2,
				WorldHeight = worldHeight,
				WorldWidth = Mathf.Max(worldHeight * 0.1f, worldHeight * num)
			};
			LogTextProjectionFrameBuilt(frame, rotation, mirrored, force: false);
			return true;
		}

		private void LogTextProjectionFrameBuilt(TextProjectionFrame frame, float rotation, bool mirrored, bool force)
		{
			//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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0070: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: 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_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_worldEditorCamera == (Object)null))
			{
				Vector3 right = ((Component)_worldEditorCamera).transform.right;
				Vector3 up = ((Component)_worldEditorCamera).transform.up;
				Vector3 forward = ((Component)_worldEditorCamera).transform.forward;
				float num = Vector3.Dot(((Vector3)(ref frame.Right)).normalized, right);
				float num2 = Vector3.Dot(((Vector3)(ref frame.Up)).normalized, up);
				float num3 = Vector3.Dot(Vector3.Cross(((Vector3)(ref frame.Right)).normalized, ((Vector3)(ref frame.Up)).normalized), ((Vector3)(ref frame.Normal)).normalized);
				float num4 = Vector3.Dot(((Vector3)(ref frame.Normal)).normalized, forward);
				string text = (mirrored ? "flipped" : "normal");
				string text2 = string.Format("side={0}|rot={1}|right={2:0.###}|up={3:0.###}|hand={4:0.###}|normal={5:0.##},{6:0.##},{7:0.##}|size={8:0.###}x{9:0.###}|tool={10}|mirror={11}", mirrored ? "Mirrored" : "Primary", Mathf.RoundToInt(rotation * 10f), num, num2, num3, frame.Normal.x, frame.Normal.y, frame.Normal.z, frame.WorldWidth, frame.WorldHeight, _tool, _mirrorEnabled);
				if (force || !(Time.unscaledTime - _lastTextProjectionFrameLogTime < 0.75f) || !string.Equals(text2, _lastTextProjectionFrameLogKey, StringComparison.Ordinal))
				{
					_lastTextProjectionFrameLogTime = Time.unscaledTime;
					_lastTextProjectionFrameLogKey = text2;
					DrawableSuitsDiagnostics.Info($"TextProjectionFrameBuilt: {text2}; cameraFacing={num4:0.###}; sampleOrder={text}; center={frame.Center}; right={frame.Right}; up={frame.Up}; normal={frame.Normal}; pointerSource={_pointerSource}; cursor={_cursor}");
				}
			}
		}

		private float CalculateTextWorldHeight()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			float num;
			if (!((Object)(object)_worldAvatarRenderer != (Object)null))
			{
				num = 1.8f;
			}
			else
			{
				Bounds bounds = ((Renderer)_worldAvatarRenderer).bounds;
				num = ((Bounds)(ref bounds)).size.y;
			}
			float num2 = num;
			if (num2 <= 0.01f)
			{
				num2 = 1.8f;
			}
			return Mathf.Clamp(_textSize / 512f * num2, num2 * 0.012f, num2 * 0.45f);
		}

		private float CalculateDecalWorldHeight()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			float num;
			if (!((Object)(object)_worldAvatarRenderer != (Object)null))
			{
				num = 1.8f;
			}
			else
			{
				Bounds bounds = ((Renderer)_worldAvatarRenderer).bounds;
				num = ((Bounds)(ref bounds)).size.y;
			}
			float num2 = num;
			if (num2 <= 0.01f)
			{
				num2 = 1.8f;
			}
			return Mathf.Clamp(_decalSize / 512f * num2, num2 * 0.012f, num2 * 0.55f);
		}

		private float CalculateStickerWorldHeight()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			float num;
			if (!((Object)(object)_worldAvatarRenderer != (Object)null))
			{
				num = 1.8f;
			}
			else
			{
				Bounds bounds = ((Renderer)_worldAvatarRenderer).bounds;
				num = ((Bounds)(ref bounds)).size.y;
			}
			float num2 = num;
			if (num2 <= 0.01f)
			{
				num2 = 1.8f;
			}
			return Mathf.Clamp(_stickerSize / 512f * num2, num2 * 0.012f, num2 * 0.55f);
		}

		private bool TryRaycastSurfaceStampPoint(Vector3 planePoint, Vector3 normal, float offset, float distance, out RaycastHit hit)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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_0049: 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_0055: 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)
			hit = default(RaycastHit);
			if ((Object)(object)_worldPaintCollider == (Object)null)
			{
				return false;
			}
			Ray val = default(Ray);
			((Ray)(ref val))..ctor(planePoint + normal * offset, -normal);
			if (((Collider)_worldPaintCollider).Raycast(val, ref hit, distance))
			{
				return true;
			}
			((Ray)(ref val))..ctor(planePoint - normal * offset, normal);
			return ((Collider)_worldPaintCollider).Raycast(val, ref hit, distance);
		}

		private bool TryGetMirrorWorldPlacement(MirrorPaintTarget mirrorTarget, out Vector3 point, out Vector3 normal)
		{
			//IL_0001: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			point = default(Vector3);
			normal = default(Vector3);
			if (!mirrorTarget.Enabled || !mirrorTarget.Available || (Object)(object)_worldPaintProxyObject == (Object)null)
			{
				return false;
			}
			point = _worldPaintProxyObject.transform.TransformPoint(mirrorTarget.MirroredLocalPoint);
			Vector3 val;
			Vector3 normalized;
			if (!(((Vector3)(ref mirrorTarget.MirroredLocalNormal)).sqrMagnitude > 0.0001f))
			{
				val = point - _worldPaintProxyObject.transform.position;
				normalized = ((Vector3)(ref val)).normalized;
			}
			else
			{
				val = _worldPaintProxyObject.transform.TransformDirection(mirrorTarget.MirroredLocalNormal);
				normalized = ((Vector3)(ref val)).normalized;
			}
			normal = normalized;
			if (((Vector3)(ref normal)).sqrMagnitude < 0.0001f)
			{
				normal = (((Object)(object)_worldEditorCamera != (Object)null) ? (-((Component)_worldEditorCamera).transform.forward) : Vector3.up);
			}
			return true;
		}

		private bool CompositePlacementStamp(Texture2D target, Texture2D stamp, Vector2 uv, float stampHeight, float stampRotation, float opacity, bool flipHorizontal = false, HashSet<int> touchedPixels = null, bool tintWithBrushColor = false)
		{
			//IL_0029: 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_0079: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: 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_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null || (Object)(object)stamp == (Object)null)
			{
				return false;
			}
			if (!TryResolveUvPanelPlacementFrame(target, stamp, stampHeight, stampRotation, flipHorizontal, logDiagnostics: true, out var frame))
			{
				return false;
			}
			int num = Mathf.RoundToInt(uv.x * (float)(((Texture)target).width - 1));
			int num2 = Mathf.RoundToInt(uv.y * (float)(((Texture)target).height - 1));
			bool result = false;
			Color val2 = default(Color);
			for (int i = -frame.HalfExtentY; i <= frame.HalfExtentY; i++)
			{
				for (int j = -frame.HalfExtentX; j <= frame.HalfExtentX; j++)
				{
					Vector2 val = new Vector2((float)j, (float)i);
					float num3 = Vector2.Dot(val, frame.RightAxis) / frame.Width + 0.5f;
					float num4 = Vector2.Dot(val, frame.UpAxis) / frame.Height + 0.5f;
					if (num3 < 0f || num3 > 1f || num4 < 0f || num4 > 1f)
					{
						continue;
					}
					int num5 = num + j;
					int num6 = num2 + i;
					if (num5 < 0 || num5 >= ((Texture)target).width || num6 < 0 || num6 >= ((Texture)target).height)
					{
						continue;
					}
					if (flipHorizontal)
					{
						num3 = 1f - num3;
					}
					Color pixelBilinear = stamp.GetPixelBilinear(num3, num4);
					float a = pixelBilinear.a;
					if (!(a <= 0.01f) && TryMarkTouchedPixel(target, num5, num6, touchedPixels))
					{
						Color pixel = target.GetPixel(num5, num6);
						if (tintWithBrushColor)
						{
							((Color)(ref val2))..ctor(_brushColor.r, _brushColor.g, _brushColor.b, pixel.a);
							target.SetPixel(num5, num6, Color.Lerp(pixel, val2, a * Mathf.Clamp01(opacity)));
						}
						else
						{
							target.SetPixel(num5, num6, Color.Lerp(pixel, pixelBilinear, a * Mathf.Clamp01(opacity)));
						}
						result = true;
					}
				}
			}
			return result;
		}

		private bool TryResolveUvPanelPlacementFrame(Texture2D target, Texture2D stamp, float stampHeight, float visibleRotation, bool mirrored, bool logDiagnostics, out UvPanelPlacementFrame frame)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: 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_00c3: 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_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			frame = default(UvPanelPlacementFrame);
			if ((Object)(object)target == (Object)null || (Object)(object)stamp == (Object)null)
			{
				return false;
			}
			Vector2 placementStampPixelSize = GetPlacementStampPixelSize(stamp);
			float num = Mathf.Max(1f, placementStampPixelSize.x);
			float num2 = Mathf.Max(1f, (_tool == EditorTool.Text) ? placementStampPixelSize.y : stampHeight);
			float num3 = visibleRotation * (MathF.PI / 180f);
			Vector2 panelVector = default(Vector2);
			((Vector2)(ref panelVector))..ctor(Mathf.Cos(num3), 0f - Mathf.Sin(num3));
			Vector2 panelVector2 = new Vector2(Mathf.Sin(num3), Mathf.Cos(num3));
			Vector2 val = PanelVectorToViewVector(panelVector, _uvPanelRotationQuarterTurns);
			Vector2 val2 = PanelVectorToViewVector(panelVector2, _uvPanelRotationQuarterTurns);
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(val.x * (float)((Texture)target).width, val.y * (float)((Texture)target).height);
			Vector2 val4 = default(Vector2);
			((Vector2)(ref val4))..ctor(val2.x * (float)((Texture)target).width, val2.y * (float)((Texture)target).height);
			if (((Vector2)(ref val3)).sqrMagnitude < 1E-06f || ((Vector2)(ref val4)).sqrMagnitude < 1E-06f)
			{
				return false;
			}
			Vector2 normalized = ((Vector2)(ref val3)).normalized;
			Vector2 normalized2 = ((Vector2)(ref val4)).normalized;
			Vector2 val5 = normalized * (num * 0.5f);
			Vector2 val6 = normalized2 * (num2 * 0.5f);
			Vector2 val7 = val5 + val6;
			Vector2 val8 = val5 - val6;
			Vector2 val9 = -val5 + val6;
			Vector2 val10 = -val5 - val6;
			float num4 = Mathf.Max(Mathf.Max(Mathf.Abs(val7.x), Mathf.Abs(val8.x)), Mathf.Max(Mathf.Abs(val9.x), Mathf.Abs(val10.x)));
			float num5 = Mathf.Max(Mathf.Max(Mathf.Abs(val7.y), Mathf.Abs(val8.y)), Mathf.Max(Mathf.Abs(val9.y), Mathf.Abs(val10.y)));
			int num6 = Mathf.Max(1, Mathf.CeilToInt(num4) + 1);
			int num7 = Mathf.Max(1, Mathf.CeilToInt(num5) + 1);
			float num8 = NormalizePlacementRotation(Mathf.Atan2(0f - normalized.y, normalized.x) * 57.29578f);
			frame = new UvPanelPlacementFrame
			{
				RightAxis = normalized,
				UpAxis = normalized2,
				Width = num,
				Height = num2,
				HalfExtentX = num6,
				HalfExtentY = num7,
				EffectiveRotation = num8
			};
			if (logDiagnostics)
			{
				DrawableSuitsDiagnostics.Info($"UvPlacementFrameResolved: tool={_tool}; source={CurrentPlacementName()}; suit={_selectedSuitId}; userRotation={CurrentPlacementRotation():0.##}; visibleRotation={visibleRotation:0.##}; mirrored={mirrored}; panelRotation={UvPanelRotationDegrees(_uvPanelRotationQuarterTurns)}; effectiveRotation={num8:0.##}; rightAxis={normalized}; upAxis={normalized2}; stampSize={num:0.#}x{num2:0.#}; extents={num6}x{num7}; texture={((Texture)target).width}x{((Texture)target).height}; mode=TexturePanel");
			}
			return true;
		}

		private static bool TryMarkTouchedPixel(Texture2D texture, int x, int y, HashSet<int> touchedPixels)
		{
			if (touchedPixels == null || (Object)(object)texture == (Object)null)
			{
				return true;
			}
			return touchedPixels.Add(y * ((Texture)texture).width + x);
		}

		private static Vector2 ClampUv(Vector2 uv)
		{
			//IL_0000: 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_0016: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(Mathf.Clamp01(uv.x), Mathf.Clamp01(uv.y));
		}

		private static float Cross2D(Vector2 a, Vector2 b)
		{
			//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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return a.x * b.y - a.y * b.x;
		}

		private static bool TryBarycentric2D(Vector2 p, Vector2 a, Vector2 b, Vector2 c, out Vector3 barycentric, float epsilon)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			barycentric = default(Vector3);
			Vector2 a2 = b - a;
			Vector2 b2 = c - a;
			Vector2 val = p - a;
			float num = Cross2D(a2, b2);
			if (Mathf.Abs(num) < 1E-07f)
			{
				return false;
			}
			float num2 = Cross2D(val, b2) / num;
			float num3 = Cross2D(a2, val) / num;
			float num4 = 1f - num2 - num3;
			if (num4 < 0f - epsilon || num2 < 0f - epsilon || num3 < 0f - epsilon || num4 > 1f + epsilon || num2 > 1f + epsilon || num3 > 1f + epsilon)
			{
				return false;
			}
			barycentric = new Vector3(num4, num2, num3);
			return true;
		}

		private static bool TryBarycentric3D(Vector3 p, Vector3 a, Vector3 b, Vector3 c, out Vector3 barycentric)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			barycentric = default(Vector3);
			Vector3 val = b - a;
			Vector3 val2 = c - a;
			Vector3 val3 = p - a;
			float num = Vector3.Dot(val, val);
			float num2 = Vector3.Dot(val, val2);
			float num3 = Vector3.Dot(val2, val2);
			float num4 = Vector3.Dot(val3, val);
			float num5 = Vector3.Dot(val3, val2);
			float num6 = num * num3 - num2 * num2;
			if (Mathf.Abs(num6) < 1E-07f)
			{
				return false;
			}
			float num7 = (num3 * num4 - num2 * num5) / num6;
			float num8 = (num * num5 - num2 * num4) / num6;
			float num9 = 1f - num7 - num8;
			barycentric = new Vector3(num9, num7, num8);
			return true;
		}

		private static Vector3 ClosestPointOnTriangle(Vector3 point, Vector3 a, Vector3 b, Vector3 c)
		{
			//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)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_0043: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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_00ba: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: 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_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: 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_0159: 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_0165: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = b - a;
			Vector3 val2 = c - a;
			Vector3 val3 = point - a;
			float num = Vector3.Dot(val, val3);
			float num2 = Vector3.Dot(val2, val3);
			if (num <= 0f && num2 <= 0f)
			{
				return a;
			}
			Vector3 val4 = point - b;
			float num3 = Vector3.Dot(val, val4);
			float num4 = Vector3.Dot(val2, val4);
			if (num3 >= 0f && num4 <= num3)
			{
				return b;
			}
			float num5 = num * num4 - num3 * num2;
			if (num5 <= 0f && num >= 0f && num3 <= 0f)
			{
				float num6 = num / (num - num3);
				return a + val * num6;
			}
			Vector3 val5 = point - c;
			float num7 = Vector3.Dot(val, val5);
			float num8 = Vector3.Dot(val2, val5);
			if (num8 >= 0f && num7 <= num8)
			{
				return c;
			}
			float num9 = num7 * num2 - num * num8;
			if (num9 <= 0f && num2 >= 0f && num8 <= 0f)
			{
				float num10 = num2 / (num2 - num8);
				return a + val2 * num10;
			}
			float num11 = num3 * num8 - num7 * num4;
			if (num11 <= 0f && num4 - num3 >= 0f && num7 - num8 >= 0f)
			{
				float num12 = (num4 - num3) / (num4 - num3 + (num7 - num8));
				return b + (c - b) * num12;
			}
			float num13 = 1f / (num11 + num9 + num5);
			float num14 = num9 * num13;
			float num15 = num5 * num13;
			return a + val * num14 + val2 * num15;
		}

		private void SaveUndo(string label)
		{
			Texture2D editableTexture = DrawableSuitsPlugin.Registry.GetEditableTexture(_selectedSuitId);
			if (!((Object)(object)editableTexture == (Object)null))
			{
				string text = (string.IsNullOrWhiteSpace(label) ? "Edit" : label.Trim());
				ClearUndoHistorySelection("new undo entry", updateUi: false);
				long num = _nextUndoHistoryId++;
				_undo.Push(new UndoHistoryEntry
				{
					Id = num,
					Pixels = editableTexture.GetPixels32(),
					Label = text
				});
				while (_undo.Count > DrawableSuitsPlugin.ModConfig.MaxUndoStates.Value)
				{
					UndoHistoryEntry undoHistoryEntry = TrimOldest(_undo);
					DrawableSuitsDiagnostics.Info(string.Format("UndoHistoryTrimmed: id={0}; label={1}; undoCount={2}; redoCount={3}; max={4}", undoHistoryEntry?.Id ?? 0, undoHistoryEntry?.Label ?? "unknown", _undo.Count, _redo.Count, DrawableSuitsPlugin.ModConfig.MaxUndoStates.Value));
				}
				UpdateUndoHistoryUi();
				DrawableSuitsDiagnostics.Info($"UndoHistoryPushed: id={num}; label={text}; undoCount={_undo.Count}; redoCount={_redo.Count}; max={DrawableSuitsPlugin.ModConfig.MaxUndoStates.Value}");
			}
		}

		private void Undo()
		{
			Texture2D editableTexture = DrawableSuitsPlugin.Registry.GetEditableTexture(_selectedSuitId);
			if (!((Object)(object)editableTexture == (Object)null) && _undo.Count != 0)
			{
				UndoHistoryEntry undoHistoryEntry = _undo.Pop();
				_redo.Push(new UndoHistoryEntry
				{
					Id = undoHistoryEntry.Id,
					Pixels = editableTexture.GetPixels32(),
					Label = undoHistoryEntry.Label
				});
				editableTexture.SetPixels32(undoHistoryEntry.Pixels);
				editableTexture.Apply(false, false);
				DrawableSuitsPlugin.Registry.ApplyEditedTexture(_selectedSuitId, _designName, broadcast: false);
				InvalidateDecalPreview("undo");
				RefreshTexturePanelPreview("Undo", forceLog: false);
				ClearUndoHistorySelection("undo one step", updateUi: false);
				UpdateUndoHistoryUi();
				DrawableSuitsDiagnostics.Info($"UndoHistoryUndo: id={undoHistoryEntry.Id}; label={undoHistoryEntry.Label}; undoCount={_undo.Count}; redoCount={_redo.Count}; max={DrawableSuitsPlugin.ModConfig.MaxUndoStates.Value}");
			}
		}

		private void SelectUndoHistoryEntry(long entryId)
		{
			if (IsEditorModalOpen())
			{
				DrawableSuitsDiagnostics.Warn($"UndoHistoryRowSelected ignored because a modal is open. id={entryId}; undoCount={_undo.Count}; redoCount={_redo.Count}");
				return;
			}
			UndoHistoryEntry[] array = _undo.ToArray();
			int num = FindUndoHistoryIndexById(array, entryId);
			if (num < 0)
			{
				DrawableSuitsDiagnostics.Warn($"UndoHistoryRowSelected ignored because id was not found. id={entryId}; undoCount={_undo.Count}; redoCount={_redo.Count}");
				ClearUndoHistorySelection("selected row missing", updateUi: true);
				return;
			}
			_selectedUndoHistoryId = entryId;
			string label = array[num].Label;
			SetStatus("Will undo only " + label + ".", warn: false);
			UpdateUndoHistoryUi();
			DrawableSuitsDiagnostics.Info($"UndoHistoryRowSelected: id={entryId}; index={num}; label={label}; undoCount={_undo.Count}; redoCount={_redo.Count}; max={DrawableSuitsPlugin.ModConfig.MaxUndoStates.Value}");
		}

		private void UndoToSelectedHistory()
		{
			if (IsEditorModalOpen())
			{
				LogSelectiveUndoSkipped("modal open", _selectedUndoHistoryId, -1, null, 0, 0, 0, 0, 0);
				return;
			}
			if (_selectedUndoHistoryId == 0L)
			{
				SetStatus("Select a history row first.", warn: false);
				LogSelectiveUndoSkipped("no row selected", 0L, -1, null, 0, 0, 0, 0, 0);
				return;
			}
			UndoHistoryEntry[] entries = _undo.ToArray();
			int num = FindUndoHistoryIndexById(entries, _selectedUndoHistoryId);
			if (num < 0)
			{
				SetStatus("Selected history row is no longer available.", warn: false);
				LogSelectiveUndoSkipped("selected row stale", _selectedUndoHistoryId, -1, null, 0, 0, 0, 0, 0);
				ClearUndoHistorySelection("selected row stale", updateUi: true);
			}
			else
			{
				UndoSelectedHistoryIndex(num, _selectedUndoHistoryId);
			}
		}

		private void UndoSelectedHistoryIndex(int newestFirstIndex, long expectedId)
		{
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			Texture2D editableTexture = DrawableSuitsPlugin.Registry.GetEditableTexture(_selectedSuitId);
			if ((Object)(object)editableTexture == (Object)null || newestFirstIndex < 0 || newestFirstIndex >= _undo.Count)
			{
				LogSelectiveUndoSkipped("invalid selection or missing texture", expectedId, newestFirstIndex, null, 0, 0, 0, 0, 0);
				return;
			}
			UndoHistoryEntry[] array = _undo.ToArray();
			if (expectedId > 0 && array[newestFirstIndex].Id != expectedId)
			{
				int num = FindUndoHistoryIndexById(array, expectedId);
				if (num < 0)
				{
					LogSelectiveUndoSkipped("expected id not found", expectedId, newestFirstIndex, null, 0, 0, 0, 0, 0);
					ClearUndoHistorySelection("expected row missing", updateUi: true);
					return;
				}
				newestFirstIndex = num;
			}
			UndoHistoryEntry undoHistoryEntry = array[newestFirstIndex];
			string label = undoHistoryEntry.Label;
			Color32[] pixels;
			try
			{
				pixels = editableTexture.GetPixels32();
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception($"UndoHistorySelectiveUndo GetPixels32 failed. selectedId={undoHistoryEntry.Id}; index={newestFirstIndex}; label={label}; texture={DrawableSuitsPlugin.DescribeUnityObject((Object)(object)editableTexture)}", exception);
				LogSelectiveUndoSkipped("texture read failed", undoHistoryEntry.Id, newestFirstIndex, label, 0, 0, 0, 0, 0);
				return;
			}
			Color32[] pixels2 = undoHistoryEntry.Pixels;
			Color32[] array2 = ((newestFirstIndex == 0) ? pixels : array[newestFirstIndex - 1].Pixels);
			if (pixels2 == null || array2 == null || pixels2.Length != pixels.Length || array2.Length != pixels.Length)
			{
				LogSelectiveUndoSkipped($"snapshot dimensions mismatch before={((pixels2 != null) ? pixels2.Length : 0)} after={((array2 != null) ? array2.Length : 0)} current={pixels.Length}", undoHistoryEntry.Id, newestFirstIndex, label, 0, 0, 0, 0, 0);
				SetStatus("Selected history row cannot be selectively undone because its snapshots do not match.", warn: false);
				return;
			}
			Color32[] array3 = (Color32[])pixels.Clone();
			Color32[] pixels3 = (Color32[])pixels.Clone();
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			List<int> list = new List<int>();
			for (int i = 0; i < pixels.Length; i++)
			{
				if (!Color32Equals(pixels2[i], array2[i]))
				{
					num2++;
					list.Add(i);
					if (Color32Equals(pixels[i], array2[i]))
					{
						array3[i] = pixels2[i];
						num3++;
					}
					else
					{
						num4++;
					}
				}
			}
			if (num2 == 0)
			{
				LogSelectiveUndoSkipped("selected action has no detectable pixel diff", undoHistoryEntry.Id, newestFirstIndex, label, num2, num3, num4, 0, 0);
				SetStatus("Selected history row has no detectable pixel changes.", warn: false);
				return;
			}
			int num5 = 0;
			int num6 = 0;
			for (int j = 0; j < newestFirstIndex; j++)
			{
				UndoHistoryEntry undoHistoryEntry2 = array[j];
				if (undoHistoryEntry2?.Pixels == null || undoHistoryEntry2.Pixels.Length != pixels.Length)
				{
					continue;
				}
				int num7 = 0;
				for (int k = 0; k < list.Count; k++)
				{
					int num8 = list[k];
					if (Color32Equals(undoHistoryEntry2.Pixels[num8], array2[num8]))
					{
						undoHistoryEntry2.Pixels[num8] = pixels2[num8];
						num7++;
					}
				}
				if (num7 > 0)
				{
					num5++;
					num6 += num7;
				}
			}
			List<UndoHistoryEntry> list2 = new List<UndoHistoryEntry>(Mathf.Max(0, array.Length - 1));
			for (int l = 0; l < array.Length; l++)
			{
				if (l != newestFirstIndex)
				{
					list2.Add(array[l]);
				}
			}
			RebuildUndoStackFromNewestFirst(list2);
			_redo.Push(new UndoHistoryEntry
			{
				Id = undoHistoryEntry.Id,
				Pixels = pixels3,
				Label = label
			});
			if (num3 > 0)
			{
				editableTexture.SetPixels32(array3);
				editableTexture.Apply(false, false);
			}
			DrawableSuitsPlugin.Registry.ApplyEditedTexture(_selectedSuitId, _designName, broadcast: false);
			InvalidateDecalPreview("selective undo");
			RefreshTexturePanelPreview("UndoSelectedHistory", forceLog: false);
			ClearUndoHistorySelection("undo selected", updateUi: false);
			UpdateUndoHistoryUi();
			SetStatus((num3 > 0) ? $"Undid only {label}. Preserved {num4} newer-overlap pixels." : ("Removed " + label + " from history; newer edits already covered its pixels."), warn: false);
			DrawableSuitsDiagnostics.Info($"UndoHistorySelectiveUndo: selectedId={undoHistoryEntry.Id}; index={newestFirstIndex}; label={label}; changedPixels={num2}; restoredPixels={num3}; preservedOverlapPixels={num4}; rewrittenEntries={num5}; rewrittenPixels={num6}; undoCount={_undo.Count}; redoCount={_redo.Count}; max={DrawableSuitsPlugin.ModConfig.MaxUndoStates.Value}");
			if (num5 > 0)
			{
				DrawableSuitsDiagnostics.Info($"UndoHistorySnapshotsRewritten: selectedId={undoHistoryEntry.Id}; label={label}; updatedSnapshotCount={num5}; updatedPixelCount={num6}; undoCount={_undo.Count}; redoCount={_redo.Count}");
			}
		}

		private void Redo()
		{
			Texture2D editableTexture = DrawableSuitsPlugin.Registry.GetEditableTexture(_selectedSuitId);
			if (!((Object)(object)editableTexture == (Object)null) && _redo.Count != 0)
			{
				UndoHistoryEntry undoHistoryEntry = _redo.Pop();
				_undo.Push(new UndoHistoryEntry
				{
					Id = undoHistoryEntry.Id,
					Pixels = editableTexture.GetPixels32(),
					Label = undoHistoryEntry.Label
				});
				editableTexture.SetPixels32(undoHistoryEntry.Pixels);
				editableTexture.Apply(false, false);
				DrawableSuitsPlugin.Registry.ApplyEditedTexture(_selectedSuitId, _designName, broadcast: false);
				InvalidateDecalPreview("redo");
				RefreshTexturePanelPreview("Redo", forceLog: false);
				ClearUndoHistorySelection("redo one step", updateUi: false);
				UpdateUndoHistoryUi();
				DrawableSuitsDiagnostics.Info($"UndoHistoryRedo: id={undoHistoryEntry.Id}; label={undoHistoryEntry.Label}; undoCount={_undo.Count}; redoCount={_redo.Count}; max={DrawableSuitsPlugin.ModConfig.MaxUndoStates.Value}");
			}
		}

		private static UndoHistoryEntry TrimOldest(Stack<UndoHistoryEntry> stack)
		{
			UndoHistoryEntry[] array = stack.ToArray();
			stack.Clear();
			for (int num = array.Length - 2; num >= 0; num--)
			{
				stack.Push(array[num]);
			}
			if (array.Length == 0)
			{
				return null;
			}
			return array[^1];
		}

		private void ClearUndoHistory(string reason)
		{
			if (_undo.Count != 0 || _redo.Count != 0 || _selectedUndoHistoryId != 0L)
			{
				_undo.Clear();
				_redo.Clear();
				ClearUndoHistorySelection(reason, updateUi: false);
				UpdateUndoHistoryUi();
				DrawableSuitsDiagnostics.Info($"UndoHistoryCleared: reason={reason}; undoCount=0; redoCount=0; max={DrawableSuitsPlugin.ModConfig.MaxUndoStates.Value}");
			}
		}

		private void ClearUndoHistoryByUser()
		{
			if (_undo.Count == 0 && _redo.Count == 0)
			{
				SetStatus("No undo history to clear.", warn: false);
				return;
			}
			int count = _undo.Count;
			int count2 = _redo.Count;
			ClearUndoHistory("user clear history");
			SetStatus("Undo history cleared.", warn: false);
			DrawableSuitsDiagnostics.Info($"UndoHistoryClearedByUser: previousUndoCount={count}; previousRedoCount={count2}; undoCount={_undo.Count}; redoCount={_redo.Count}; max={DrawableSuitsPlugin.ModConfig.MaxUndoStates.Value}");
		}

		private void ClearRedoHistory(string reason)
		{
			if (_redo.Count != 0)
			{
				_redo.Clear();
				UpdateUndoHistoryUi();
				DrawableSuitsDiagnostics.Info($"UndoHistoryRedoCleared: reason={reason}; undoCount={_undo.Count}; redoCount=0; max={DrawableSuitsPlugin.ModConfig.MaxUndoStates.Value}");
			}
		}

		private void DropLastUndoEntry(string reason)
		{
			if (_undo.Count != 0)
			{
				UndoHistoryEntry undoHistoryEntry = _undo.Pop();
				if (undoHistoryEntry.Id == _selectedUndoHistoryId)
				{
					ClearUndoHistorySelection(reason, updateUi: false);
				}
				UpdateUndoHistoryUi();
				DrawableSuitsDiagnostics.Info($"UndoHistoryDropped: reason={reason}; id={undoHistoryEntry.Id}; label={undoHistoryEntry.Label}; undoCount={_undo.Count}; redoCount={_redo.Count}; max={DrawableSuitsPlugin.ModConfig.MaxUndoStates.Value}");
			}
		}

		private int FindUndoHistoryIndexById(UndoHistoryEntry[] entries, long entryId)
		{
			if (entries == null || entryId == 0L)
			{
				return -1;
			}
			for (int i = 0; i < entries.Length; i++)
			{
				if (entries[i] != null && entries[i].Id == entryId)
				{
					return i;
				}
			}
			return -1;
		}

		private static bool Color32Equals(Color32 left, Color32 right)
		{
			//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_000e: 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_001c: 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_002a: 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)
			if (left.r == right.r && left.g == right.g && left.b == right.b)
			{
				return left.a == right.a;
			}
			return false;
		}

		private void RebuildUndoStackFromNewestFirst(List<UndoHistoryEntry> entries)
		{
			_undo.Clear();
			if (entries == null)
			{
				return;
			}
			for (int num = entries.Count - 1; num >= 0; num--)
			{
				if (entries[num] != null)
				{
					_undo.Push(entries[num]);
				}
			}
		}

		private void LogSelectiveUndoSkipped(string reason, long selectedId, int index, string label, int changedPixels, int restoredPixels, int preservedOverlapPixels, int rewrittenEntries, int rewrittenPixels)
		{
			DrawableSuitsDiagnostics.Warn(string.Format("UndoHistorySelectiveUndoSkipped: reason={0}; selectedId={1}; index={2}; label={3}; changedPixels={4}; restoredPixels={5}; preservedOverlapPixels={6}; rewrittenEntries={7}; rewrittenPixels={8}; undoCount={9}; redoCount={10}; max={11}", reason, selectedId, index, label ?? "unknown", changedPixels, restoredPixels, preservedOverlapPixels, rewrittenEntries, rewrittenPixels, _undo.Count, _redo.Count, DrawableSuitsPlugin.ModConfig.MaxUndoStates.Value));
		}

		private void ClearUndoHistorySelection(string reason, bool updateUi)
		{
			if (_selectedUndoHistoryId != 0L)
			{
				long selectedUndoHistoryId = _selectedUndoHistoryId;
				_selectedUndoHistoryId = 0L;
				if (updateUi)
				{
					UpdateUndoHistoryUi();
				}
				DrawableSuitsDiagnostics.Info($"UndoHistorySelectionCleared: reason={reason}; previousId={selectedUndoHistoryId}; undoCount={_undo.Count}; redoCount={_redo.Count}; max={DrawableSuitsPlugin.ModConfig.MaxUndoStates.Value}");
			}
		}

		private void UpdateUndoHistoryUi()
		{
			//IL_00ee: 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_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Expected O, but got Unknown
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			UndoHistoryEntry[] array = _undo.ToArray();
			int num = FindUndoHistoryIndexById(array, _selectedUndoHistoryId);
			if (_selectedUndoHistoryId != 0L && num < 0)
			{
				ClearUndoHistorySelection("selection no longer in undo stack", updateUi: false);
			}
			bool flag = _selectedUndoHistoryId != 0L && num >= 0;
			if ((Object)(object)_undoHistoryEmptyLabel != (Object)null)
			{
				((Component)_undoHistoryEmptyLabel).gameObject.SetActive(array.Length == 0);
			}
			SetInteractable((Selectable)(object)_undoToSelectedButton, flag);
			SetInteractable((Selectable)(object)_clearUndoHistoryButton, _undo.Count > 0 || _redo.Count > 0);
			if ((Object)(object)_undoHistorySelectionLabel != (Object)null)
			{
				if (flag)
				{
					_undoHistorySelectionLabel.text = "Will undo only " + array[num].Label + ".";
					((Graphic)_undoHistorySelectionLabel).color = new Color(1f, 0.68f, 0.36f, 1f);
				}
				else
				{
					_undoHistorySelectionLabel.text = ((array.Length != 0) ? "Select a row first." : "No history.");
					((Graphic)_undoHistorySelectionLabel).color = new Color(0.82f, 0.86f, 0.9f, 1f);
				}
			}
			for (int i = 0; i < _undoHistoryRows.Count; i++)
			{
				UndoHistoryRow undoHistoryRow = _undoHistoryRows[i];
				if (undoHistoryRow == null || (Object)(object)undoHistoryRow.GameObject == (Object)null)
				{
					continue;
				}
				bool flag2 = i < array.Length;
				undoHistoryRow.GameObject.SetActive(flag2);
				undoHistoryRow.Index = (flag2 ? i : (-1));
				undoHistoryRow.EntryId = (flag2 ? array[i].Id : 0);
				if ((Object)(object)undoHistoryRow.Button != (Object)null)
				{
					((UnityEventBase)undoHistoryRow.Button.onClick).RemoveAllListeners();
					((Selectable)undoHistoryRow.Button).interactable = flag2;
				}
				if (!flag2)
				{
					continue;
				}
				long rowEntryId = undoHistoryRow.EntryId;
				string label = array[i].Label;
				if ((Object)(object)undoHistoryRow.Button != (Object)null)
				{
					((UnityEvent)undoHistoryRow.Button.onClick).AddListener((UnityAction)delegate
					{
						SelectUndoHistoryEntry(rowEntryId);
						ClearSelectedNormalButton();
					});
				}
				if ((Object)(object)undoHistoryRow.Label != (Object)null)
				{
					undoHistoryRow.Label.text = label;
				}
				if ((Object)(object)undoHistoryRow.Button != (Object)null)
				{
					if (undoHistoryRow.EntryId == _selectedUndoHistoryId)
					{
						ApplySelectedListButtonStyle(undoHistoryRow.Button);
					}
					else
					{
						ApplyNormalListButtonStyle(undoHistoryRow.Button);
					}
				}
				else if ((Object)(object)undoHistoryRow.Image != (Object)null)
				{
					((Graphic)undoHistoryRow.Image).color = ((undoHistoryRow.EntryId == _selectedUndoHistoryId) ? TerminalAccentColor : TerminalInputColor);
				}
			}
		}

		private void SaveDesign()
		{
			DrawableSuitsDiagnostics.Info($"SaveDesign requested. selectedSuitId={_selectedSuitId}; designName={_designName}");
			if (DrawableSuitsPlugin.Registry.SaveDesign(_selectedSuitId, _designName))
			{
				string selectedFilePath = GetSelectedFilePath(_designFiles, _selectedDesignIndex);
				RefreshFileLists();
				_selectedDesignIndex = FindFileIndex(_designFiles, selectedFilePath);
				SetStatus("Design saved.", warn: false);
				if (IsSavedDesignsPanelOpen())
				{
					SetSavedDesignsStatus("Saved " + _designName + ". Select a design to load it.");
				}
				UpdateUiState();
				DrawableSuitsDiagnostics.Info(string.Format("SaveDesign succeeded. preservedSelectedDesign={0}; selectedDesignIndex={1}", selectedFilePath ?? "none", _selectedDesignIndex));
			}
			else
			{
				DrawableSuitsDiagnostics.Warn("SaveDesign failed; registry returned false.");
			}
		}

		private void LoadSelectedDesign()
		{
			if (_selectedDesignIndex < 0 || _selectedDesignIndex >= _designFiles.Count)
			{
				DrawableSuitsDiagnostics.Warn($"LoadSelectedDesign ignored. selectedDesignIndex={_selectedDesignIndex}; designCount={_designFiles.Count}");
				SetSavedDesignsStatus("Select a saved design first.");
				return;
			}
			DrawableSuitsDiagnostics.Info($"LoadSelectedDesign requested. file={_designFiles[_selectedDesignIndex]}; selectedSuitId={_selectedSuitId}");
			SaveUndo("Load design");
			if (DrawableSuitsPlugin.Registry.LoadDesign(_selectedSuitId, _designFiles[_selectedDesignIndex]))
			{
				ClearRedoHistory("load design");
				_designName = Path.GetFileNameWithoutExtension(_designFiles[_selectedDesignIndex]);
				if ((Object)(object)_designNameInput != (Object)null)
				{
					_designNameInput.text = _designName;
				}
				RefreshEditorReadiness("before load design preview");
				InvalidateDecalPreview("load design");
				TryRebuildPreviewForCurrentReadiness("LoadSelectedDesign");
				RefreshEditorReadiness("after load design");
				UpdateUiState();
				SetSavedDesignsStatus("Loaded " + _designName + " into the current suit.");
				DrawableSuitsDiagnostics.Info($"SavedDesignsPanelLoaded: designName={_designName}; selectedDesignIndex={_selectedDesignIndex}; file={_designFiles[_selectedDesignIndex]}; undoCount={_undo.Count}; redoCount={_redo.Count}");
				DrawableSuitsDiagnostics.Info("LoadSelectedDesign succeeded.");
			}
			else
			{
				DropLastUndoEntry("Load design failed");
				SetSavedDesignsStatus("Load failed. Check diagnostics.");
				DrawableSuitsDiagnostics.Warn("LoadSelectedDesign failed; registry returned false.");
			}
		}

		private void RefreshFileLists()
		{
			DrawableSuitsPaths.EnsureCreated();
			string selectedFilePath = GetSelectedFilePath(_designFiles, _selectedDesignIndex);
			string selectedFilePath2 = GetSelectedFilePath(_decalFiles, _selectedDecalIndex);
			_designFiles.Clear();
			_designFiles.AddRange(Directory.GetFiles(DrawableSuitsPaths.Saves, "*.json"));
			_designFiles.Sort(StringComparer.OrdinalIgnoreCase);
			_decalFiles.Clear();
			string[] files = Directory.GetFiles(DrawableSuitsPaths.Decals);
			foreach (string text in files)
			{
				if (TextureTools.IsImagePath(text))
				{
					_decalFiles.Add(text);
				}
			}
			_decalFiles.Sort(StringComparer.OrdinalIgnoreCase);
			_selectedDesignIndex = FindFileIndex(_designFiles, selectedFilePath);
			_selectedDecalIndex = FindFileIndex(_decalFiles, selectedFilePath2);
			RefreshListButtons();
			DrawableSuitsDiagnostics.Info($"RefreshFileLists complete. designCount={_designFiles.Count}; decalCount={_decalFiles.Count}; selectedDesign={_selectedDesignIndex}; selectedDecal={_selectedDecalIndex}; savesPath={DrawableSuitsPaths.Saves}; decalsPath={DrawableSuitsPaths.Decals}");
		}

		private static string GetSelectedFilePath(List<string> files, int index)
		{
			if (index < 0 || index >= files.Count)
			{
				return null;
			}
			return files[index];
		}

		private static int FindFileIndex(List<string> files, string selectedPath)
		{
			if (string.IsNullOrWhiteSpace(selectedPath))
			{
				return -1;
			}
			for (int i = 0; i < files.Count; i++)
			{
				if (string.Equals(files[i], selectedPath, StringComparison.OrdinalIgnoreCase))
				{
					return i;
				}
			}
			return -1;
		}

		private void OpenDesignCodePanel(bool exportCurrent)
		{
			if (!((Object)(object)_designCodePanelObject == (Object)null))
			{
				CancelPendingFileDeletes("open design code panel");
				_designCodePanelObject.SetActive(true);
				if ((Object)(object)_designCodeStatusLabel != (Object)null)
				{
					_designCodeStatusLabel.text = (exportCurrent ? "Generating code for the current editable texture..." : "Paste a DSUIT2 or DSUIT1 code, then press Import.");
				}
				if (!exportCurrent && (Object)(object)_designCodeInput != (Object)null)
				{
					string systemCopyBuffer = GUIUtility.systemCopyBuffer;
					_designCodeInput.text = (DrawableSuitDesignCode.HasSupportedPrefix(systemCopyBuffer) ? systemCopyBuffer : string.Empty);
				}
				if (exportCurrent)
				{
					CopyCurrentDesignCode();
				}
				RebuildSelectableNavigation();
				DrawableSuitsDiagnostics.Info($"DesignCodePanel opened. exportCurrent={exportCurrent}; selectedSuitId={_selectedSuitId}; designName={_designName}");
			}
		}

		private void CloseDesignCodePanel()
		{
			if ((Object)(object)_designCodePanelObject != (Object)null)
			{
				_designCodePanelObject.SetActive(false);
			}
		}

		private void OpenSavedDesignsPanel()
		{
			if (!((Object)(object)_savedDesignsPanelObject == (Object)null))
			{
				CancelPendingFileDeletes("open saved designs panel");
				RefreshFileLists();
				_savedDesignsPanelObject.SetActive(true);
				SetSavedDesignsStatus((_designFiles.Count == 0) ? "No saved designs found. Press Save to create one." : "Select a saved design, then press Load Selected.");
				UpdateUiState();
				RebuildSelectableNavigation();
				DrawableSuitsDiagnostics.Info(string.Format("SavedDesignsPanelOpened: designCount={0}; selectedDesignIndex={1}; selectedDesign={2}", _designFiles.Count, _selectedDesignIndex, GetSelectedFilePath(_designFiles, _selectedDesignIndex) ?? "none"));
			}
		}

		private void CloseSavedDesignsPanel()
		{
			bool num = IsSavedDesignsPanelOpen();
			CancelPendingDesignDelete("close saved designs panel");
			if ((Object)(object)_savedDesignsPanelObject != (Object)null)
			{
				_savedDesignsPanelObject.SetActive(false);
			}
			SetSavedDesignsStatus(string.Empty);
			RebuildSelectableNavigation();
			if (num)
			{
				DrawableSuitsDiagnostics.Info(string.Format("SavedDesignsPanelClosed: selectedDesignIndex={0}; selectedDesign={1}", _selectedDesignIndex, GetSelectedFilePath(_designFiles, _selectedDesignIndex) ?? "none"));
			}
		}

		private void RefreshSavedDesignsPanel()
		{
			CancelPendingDesignDelete("refresh saved designs panel");
			RefreshFileLists();
			SetSavedDesignsStatus((_designFiles.Count == 0) ? "No saved designs found." : string.Format("Loaded {0} saved design{1}.", _designFiles.Count, (_designFiles.Count == 1) ? string.Empty : "s"));
			UpdateUiState();
			DrawableSuitsDiagnostics.Info(string.Format("SavedDesignsPanelLoaded: designCount={0}; selectedDesignIndex={1}; selectedDesign={2}", _designFiles.Count, _selectedDesignIndex, GetSelectedFilePath(_designFiles, _selectedDesignIndex) ?? "none"));
		}

		private void OpenDecalsPanel()
		{
			if (!((Object)(object)_decalsPanelObject == (Object)null))
			{
				CancelPendingFileDeletes("open decals panel");
				RefreshFileLists();
				_decalsPanelObject.SetActive(true);
				SetDecalsStatus((_decalFiles.Count == 0) ? "No decals found. Copy the folder path, add PNG/JPG files, then Refresh." : "Select a decal to load it. Copy Folder Path helps add more files manually.");
				UpdateUiState();
				RebuildSelectableNavigation();
				DrawableSuitsDiagnostics.Info(string.Format("DecalsPanelOpened: decalCount={0}; selectedDecalIndex={1}; selectedDecal={2}", _decalFiles.Count, _selectedDecalIndex, GetSelectedFilePath(_decalFiles, _selectedDecalIndex) ?? "none"));
			}
		}

		private void CloseDecalsPanel()
		{
			bool num = IsDecalsPanelOpen();
			CancelPendingDecalDelete("close decals panel");
			if ((Object)(object)_decalsPanelObject != (Object)null)
			{
				_decalsPanelObject.SetActive(false);
			}
			SetDecalsStatus(string.Empty);
			RebuildSelectableNavigation();
			if (num)
			{
				DrawableSuitsDiagnostics.Info(string.Format("DecalsPanelClosed: selectedDecalIndex={0}; selectedDecal={1}", _selectedDecalIndex, GetSelectedFilePath(_decalFiles, _selectedDecalIndex) ?? "none"));
			}
		}

		private void RefreshDecalsPanel()
		{
			CancelPendingDecalDelete("refresh decals panel");
			RefreshFileLists();
			SetDecalsStatus((_decalFiles.Count == 0) ? "No decals found." : string.Format("Loaded {0} decal{1}.", _decalFiles.Count, (_decalFiles.Count == 1) ? string.Empty : "s"));
			UpdateUiState();
			DrawableSuitsDiagnostics.Info(string.Format("DecalsPanelRefreshed: decalCount={0}; selectedDecalIndex={1}; selectedDecal={2}", _decalFiles.Count, _selectedDecalIndex, GetSelectedFilePath(_decalFiles, _selectedDecalIndex) ?? "none"));
		}

		private void SetDecalsStatus(string message)
		{
			if ((Object)(object)_decalsStatusLabel != (Object)null)
			{
				_decalsStatusLabel.text = message ?? string.Empty;
			}
		}

		private void OpenStickersPanel()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_stickersPanelObject == (Object)null))
			{
				CancelPendingFileDeletes("open stickers panel");
				_stickersPanelObject.SetActive(true);
				UpdateStickerShapeButton();
				SetStickersStatus("Selected: " + StickerShapeDisplayName(_stickerShape) + ".");
				RebuildSelectableNavigation();
				DrawableSuitsDiagnostics.Info($"StickersPanelOpened: shape={_stickerShape}; display={StickerShapeDisplayName(_stickerShape)}; tool={_tool}; cursor={_cursor}");
			}
		}

		private void CloseStickersPanel()
		{
			bool num = IsStickersPanelOpen();
			if ((Object)(object)_stickersPanelObject != (Object)null)
			{
				_stickersPanelObject.SetActive(false);
			}
			SetStickersStatus(string.Empty);
			RebuildSelectableNavigation();
			if (num)
			{
				DrawableSuitsDiagnostics.Info($"StickersPanelClosed: shape={_stickerShape}; display={StickerShapeDisplayName(_stickerShape)}");
			}
		}

		private void SetStickersStatus(string message)
		{
			if ((Object)(object)_stickersStatusLabel != (Object)null)
			{
				_stickersStatusLabel.text = message ?? string.Empty;
			}
		}

		private void OpenPlacementEditPanel(PlacementEditTarget target)
		{
			if (!((Object)(object)_placementEditPanelObject == (Object)null))
			{
				if (target == PlacementEditTarget.Decal && (Object)(object)_loadedDecal == (Object)null)
				{
					SetStatus("Select a decal before editing it.", warn: false);
					return;
				}
				if (target == PlacementEditTarget.Sticker && !TryGetStickerStampTexture(_stickerShape, out var _, out var failureReason))
				{
					SetStatus("Sticker failed: " + failureReason + ".", warn: false);
					return;
				}
				CancelPendingFileDeletes("open placement edit panel");
				CloseDecalsPanel();
				CloseStickersPanel();
				_activePlacementEditTarget = target;
				_placementEditPanelObject.SetActive(true);
				RefreshPlacementEditPanelUi(rebuildPreview: true);
				RebuildSelectableNavigation();
				PlacementEditState placementEditState = GetPlacementEditState(target);
				DrawableSuitsDiagnostics.Info($"PlacementEditPanelOpened: target={target}; source={GetPlacementEditSourceName(target)}; crop={DescribePlacementCrop(placementEditState)}; stretch={DescribePlacementStretch(placementEditState)}; flip={DescribePlacementFlip(placementEditState)}; filters={DescribePlacementFilters(placementEditState)}; suit={_selectedSuitId}");
			}
		}

		private void ClosePlacementEditPanel()
		{
			bool num = IsPlacementEditPanelOpen();
			PlacementEditTarget activePlacementEditTarget = _activePlacementEditTarget;
			if ((Object)(object)_placementEditPanelObject != (Object)null)
			{
				_placementEditPanelObject.SetActive(false);
			}
			_activePlacementEditTarget = PlacementEditTarget.None;
			if ((Object)(object)_placementEditPreviewImage != (Object)null)
			{
				_placementEditPreviewImage.texture = null;
			}
			RebuildSelectableNavigation();
			if (num)
			{
				ClearPlacementSourcePixelCache(activePlacementEditTarget, "placement edit panel closed");
				DrawableSuitsDiagnostics.Info($"PlacementEditPanelClosed: target={activePlacementEditTarget}; source={GetPlacementEditSourceName(activePlacementEditTarget)}; suit={_selectedSuitId}");
			}
		}

		private void RefreshPlacementEditPanelUi(bool rebuildPreview = false)
		{
			if (!IsPlacementEditPanelOpen())
			{
				return;
			}
			PlacementEditTarget activePlacementEditTarget = _activePlacementEditTarget;
			PlacementEditState placementEditState = GetPlacementEditState(activePlacementEditTarget);
			if (placementEditState == null)
			{
				SetPlacementEditStatus("No editable placement selected.");
				return;
			}
			if ((Object)(object)_placementEditTitleLabel != (Object)null)
			{
				_placementEditTitleLabel.text = ((activePlacementEditTarget == PlacementEditTarget.Sticker) ? "Edit Sticker" : "Edit Decal");
			}
			if ((Object)(object)_placementEditSourceLabel != (Object)null)
			{
				_placementEditSourceLabel.text = DisplayPlacementEditSourceName(activePlacementEditTarget) + "\nTemporary edits affect preview and future stamps only.";
			}
			SetPlacementEditSliderValues(placementEditState);
			if ((Object)(object)_placementEditFlipXButton != (Object)null)
			{
				SetToolButtonColor(_placementEditFlipXButton, placementEditState.FlipX);
			}
			if ((Object)(object)_placementEditFlipYButton != (Object)null)
			{
				SetToolButtonColor(_placementEditFlipYButton, placementEditState.FlipY);
			}
			if ((Object)(object)_placementEditPreviewImage != (Object)null)
			{
				UpdatePlacementEditPreview(rebuildPreview ? "panel refresh" : "ui refresh");
			}
		}

		private void UpdatePlacementEditPreview(string reason)
		{
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			PlacementEditTarget activePlacementEditTarget = _activePlacementEditTarget;
			if (!IsPlacementEditPanelOpen() || activePlacementEditTarget == PlacementEditTarget.None)
			{
				LogPlacementEditPreviewSkipped(activePlacementEditTarget, reason, "panel closed or target missing");
				return;
			}
			if ((Object)(object)_placementEditPreviewImage == (Object)null)
			{
				LogPlacementEditPreviewSkipped(activePlacementEditTarget, reason, "preview image missing");
				return;
			}
			PlacementEditState placementEditState = GetPlacementEditState(activePlacementEditTarget);
			if (placementEditState == null)
			{
				_placementEditPreviewImage.texture = null;
				SetPlacementEditStatus("No editable placement selected.");
				LogPlacementEditPreviewSkipped(activePlacementEditTarget, reason, "state missing");
				return;
			}
			string failureReason = string.Empty;
			string failureReason2 = string.Empty;
			Texture2D texture2;
			Texture2D texture3;
			bool cacheHit;
			bool cpuPixelSamplingUsed;
			if (activePlacementEditTarget == PlacementEditTarget.Decal)
			{
				if (!TryGetPlacementEditSourceTexture(activePlacementEditTarget, out var texture, out failureReason) || !TryUpdateFastDecalEditPreview(texture, placementEditState, reason, realtimeSinceStartup, out failureReason2))
				{
					string text = (string.IsNullOrWhiteSpace(failureReason) ? failureReason2 : failureReason);
					if ((Object)(object)_placementEditPreviewImage.texture == (Object)null)
					{
						_placementEditPreviewImage.texture = null;
					}
					SetPlacementEditStatus(text);
					LogDecalEditPreviewFastSkipped(texture, placementEditState, reason, text);
					LogPlacementEditPreviewSkipped(activePlacementEditTarget, reason, text);
				}
			}
			else if (TryGetPlacementEditSourceTexture(activePlacementEditTarget, out texture2, out failureReason) && TryGetEditedPlacementPreviewStamp(activePlacementEditTarget, texture2, activePlacementEditTarget == PlacementEditTarget.Sticker, out texture3, out failureReason2, out cacheHit, out cpuPixelSamplingUsed))
			{
				_placementEditPreviewImage.texture = (Texture)(object)texture3;
				((Graphic)_placementEditPreviewImage).color = Color.white;
				FitPlacementEditPreview(texture3);
				SetPlacementEditStatus(placementEditState.IsDefault ? "No temporary edits applied." : "Temporary edit preview ready.");
				LogPlacementEditPreviewUpdated(activePlacementEditTarget, texture2, placementEditState, texture3, reason, cacheHit, cpuPixelSamplingUsed, (Time.realtimeSinceStartup - realtimeSinceStartup) * 1000f);
			}
			else
			{
				_placementEditPreviewImage.texture = null;
				string text2 = (string.IsNullOrWhiteSpace(failureReason) ? failureReason2 : failureReason);
				SetPlacementEditStatus(text2);
				LogPlacementEditPreviewSkipped(activePlacementEditTarget, reason, text2);
			}
		}

		private void SetPlacementEditSliderValues(PlacementEditState state)
		{
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			if (state == null)
			{
				return;
			}
			_placementEditCropLeftSlider?.SetValue(state.CropLeft, notify: false);
			_placementEditCropRightSlider?.SetValue(state.CropRight, notify: false);
			_placementEditCropBottomSlider?.SetValue(state.CropBottom, notify: false);
			_placementEditCropTopSlider?.SetValue(state.CropTop, notify: false);
			_placementEditStretchXSlider?.SetValue(state.StretchX, notify: false);
			_placementEditStretchYSlider?.SetValue(state.StretchY, notify: false);
			PlacementFilter[] placementFilterRows = PlacementFilterRows;
			foreach (PlacementFilter placementFilter in placementFilterRows)
			{
				float filterAmount = state.GetFilterAmount(placementFilter);
				if (_placementEditFilterSliders.TryGetValue(placementFilter, out var value))
				{
					value.SetValue(filterAmount, notify: false);
				}
				if (_placementEditFilterValueLabels.TryGetValue(placementFilter, out var value2))
				{
					value2.text = $"{Mathf.RoundToInt(filterAmount * 100f)}%";
					((Graphic)value2).color = ((filterAmount > 0.0001f) ? TerminalStatusColor : TerminalMutedTextColor);
				}
			}
			if ((Object)(object)_placementEditCropLeftLabel != (Object)null)
			{
				_placementEditCropLeftLabel.text = $"Left {Mathf.RoundToInt(state.CropLeft * 100f)}%";
			}
			if ((Object)(object)_placementEditCropRightLabel != (Object)null)
			{
				_placementEditCropRightLabel.text = $"Right {Mathf.RoundToInt(state.CropRight * 100f)}%";
			}
			if ((Object)(object)_placementEditCropBottomLabel != (Object)null)
			{
				_placementEditCropBottomLabel.text = $"Bottom {Mathf.RoundToInt(state.CropBottom * 100f)}%";
			}
			if ((Object)(object)_placementEditCropTopLabel != (Object)null)
			{
				_placementEditCropTopLabel.text = $"Top {Mathf.RoundToInt(state.CropTop * 100f)}%";
			}
			if ((Object)(object)_placementEditStretchXLabel != (Object)null)
			{
				_placementEditStretchXLabel.text = $"Width {state.StretchX:0.##}x";
			}
			if ((Object)(object)_placementEditStretchYLabel != (Object)null)
			{
				_placementEditStretchYLabel.text = $"Height {state.StretchY:0.##}x";
			}
		}

		private void OnPlacementEditChanged(string reason)
		{
			PlacementEditState placementEditState = GetPlacementEditState(_activePlacementEditTarget);
			if (placementEditState != null)
			{
				placementEditState.Revision++;
				InvalidateEditedPlacementStamp(_activePlacementEditTarget, destroyTexture: false);
				InvalidateDecalPreview("placement edit changed: " + reason);
				RefreshPlacementEditPanelUi();
				DrawableSuitsDiagnostics.Info($"PlacementEditChanged: target={_activePlacementEditTarget}; source={GetPlacementEditSourceName(_activePlacementEditTarget)}; reason={reason}; crop={DescribePlacementCrop(placementEditState)}; stretch={DescribePlacementStretch(placementEditState)}; flip={DescribePlacementFlip(placementEditState)}; filters={DescribePlacementFilters(placementEditState)}; revision={placementEditState.Revision}; suit={_selectedSuitId}");
			}
		}

		private void ResetActivePlacementEdit()
		{
			ResetPlacementEdit(_activePlacementEditTarget, "user reset edits", log: true);
			RefreshPlacementEditPanelUi(rebuildPreview: true);
			SetPlacementEditStatus("Temporary edits reset.");
		}

		private void ResetPlacementEdits(string reason, bool log)
		{
			ResetPlacementEdit(PlacementEditTarget.Decal, reason, log);
			ResetPlacementEdit(PlacementEditTarget.Sticker, reason, log);
		}

		private void ResetPlacementEdit(PlacementEditTarget target, string reason, bool log)
		{
			PlacementEditState placementEditState = GetPlacementEditState(target);
			if (placementEditState != null)
			{
				placementEditState.Reset();
				InvalidateEditedPlacementStamp(target);
				InvalidateDecalPreview("placement edit reset: " + reason);
				if (log)
				{
					DrawableSuitsDiagnostics.Info($"PlacementEditReset: target={target}; source={GetPlacementEditSourceName(target)}; reason={reason}; crop={DescribePlacementCrop(placementEditState)}; stretch={DescribePlacementStretch(placementEditState)}; flip={DescribePlacementFlip(placementEditState)}; filters={DescribePlacementFilters(placementEditState)}; revision={placementEditState.Revision}; suit={_selectedSuitId}");
				}
			}
		}

		private void TogglePlacementEditFlipX()
		{
			PlacementEditState placementEditState = GetPlacementEditState(_activePlacementEditTarget);
			if (placementEditState != null)
			{
				placementEditState.FlipX = !placementEditState.FlipX;
				OnPlacementEditChanged("flip x");
			}
		}

		private void TogglePlacementEditFlipY()
		{
			PlacementEditState placementEditState = GetPlacementEditState(_activePlacementEditTarget);
			if (placementEditState != null)
			{
				placementEditState.FlipY = !placementEditState.FlipY;
				OnPlacementEditChanged("flip y");
			}
		}

		private PlacementEditState GetPlacementEditState(PlacementEditTarget target)
		{
			return target switch
			{
				PlacementEditTarget.Decal => _decalPlacementEdit, 
				PlacementEditTarget.Sticker => _stickerPlacementEdit, 
				_ => null, 
			};
		}

		private bool TryGetPlacementEditSourceTexture(PlacementEditTarget target, out Texture2D texture, out string failureReason)
		{
			texture = null;
			failureReason = string.Empty;
			switch (target)
			{
			case PlacementEditTarget.Decal:
				if ((Object)(object)_loadedDecal == (Object)null)
				{
					failureReason = "Select a decal first.";
					return false;
				}
				texture = _loadedDecal;
				return true;
			case PlacementEditTarget.Sticker:
				return TryGetStickerStampTexture(_stickerShape, out texture, out failureReason);
			default:
				failureReason = "No placement edit target.";
				return false;
			}
		}

		private void InvalidateEditedPlacementStamp(PlacementEditTarget target, bool destroyTexture = true)
		{
			switch (target)
			{
			case PlacementEditTarget.Decal:
				if (destroyTexture && (Object)(object)_editedDecalStampTexture != (Object)null)
				{
					Object.Destroy((Object)(object)_editedDecalStampTexture);
					_editedDecalStampTexture = null;
				}
				if (destroyTexture && (Object)(object)_editedDecalPreviewStampTexture != (Object)null)
				{
					Object.Destroy((Object)(object)_editedDecalPreviewStampTexture);
					_editedDecalPreviewStampTexture = null;
				}
				_editedDecalStampKey = string.Empty;
				_editedDecalPreviewStampKey = string.Empty;
				if (destroyTexture)
				{
					_editedDecalPreviewPixelBuffer = null;
					ClearPlacementSourcePixelCache(target, "edited placement stamp invalidated");
				}
				break;
			case PlacementEditTarget.Sticker:
				if (destroyTexture && (Object)(object)_editedStickerStampTexture != (Object)null)
				{
					Object.Destroy((Object)(object)_editedStickerStampTexture);
					_editedStickerStampTexture = null;
				}
				if (destroyTexture && (Object)(object)_editedStickerPreviewStampTexture != (Object)null)
				{
					Object.Destroy((Object)(object)_editedStickerPreviewStampTexture);
					_editedStickerPreviewStampTexture = null;
				}
				_editedStickerStampKey = string.Empty;
				_editedStickerPreviewStampKey = string.Empty;
				if (destroyTexture)
				{
					ClearPlacementSourcePixelCache(target, "edited placement stamp invalidated");
				}
				break;
			}
		}

		private void DestroyPlacementEditResources()
		{
			InvalidateEditedPlacementStamp(PlacementEditTarget.Decal);
			InvalidateEditedPlacementStamp(PlacementEditTarget.Sticker);
			if ((Object)(object)_placementEditCheckerTexture != (Object)null)
			{
				Object.Destroy((Object)(object)_placementEditCheckerTexture);
				_placementEditCheckerTexture = null;
			}
		}

		private void SetPlacementEditStatus(string message)
		{
			if ((Object)(object)_placementEditStatusLabel != (Object)null)
			{
				_placementEditStatusLabel.text = message ?? string.Empty;
			}
		}

		private string GetPlacementEditSourceName(PlacementEditTarget target)
		{
			return target switch
			{
				PlacementEditTarget.Decal => (_selectedDecalIndex >= 0 && _selectedDecalIndex < _decalFiles.Count) ? Path.GetFileName(_decalFiles[_selectedDecalIndex]) : (((Object)(object)_loadedDecal != (Object)null) ? ((Object)_loadedDecal).name : "No decal selected"), 
				PlacementEditTarget.Sticker => StickerShapeDisplayName(_stickerShape), 
				_ => "None", 
			};
		}

		private string DisplayPlacementEditSourceName(PlacementEditTarget target)
		{
			if (target != PlacementEditTarget.Decal)
			{
				return GetPlacementEditSourceName(target);
			}
			return MiddleEllipsize(GetPlacementEditSourceName(target), 48);
		}

		private static string PlacementFilterDisplayName(PlacementFilter filter)
		{
			return filter switch
			{
				PlacementFilter.None => "None", 
				PlacementFilter.Grayscale => "Grayscale", 
				PlacementFilter.Invert => "Invert", 
				PlacementFilter.Sepia => "Sepia", 
				PlacementFilter.Brightness => "Brightness", 
				PlacementFilter.Contrast => "Contrast", 
				PlacementFilter.Saturation => "Saturation", 
				PlacementFilter.HueShift => "Hue Shift", 
				_ => filter.ToString(), 
			};
		}

		private static string DescribePlacementCrop(PlacementEditState state)
		{
			if (state != null)
			{
				return $"{state.CropLeft:0.###},{state.CropRight:0.###},{state.CropBottom:0.###},{state.CropTop:0.###}";
			}
			return "none";
		}

		private static string DescribePlacementCrop(PlacementEditSnapshot state)
		{
			if (state != null)
			{
				return $"{state.CropLeft:0.###},{state.CropRight:0.###},{state.CropBottom:0.###},{state.CropTop:0.###}";
			}
			return "none";
		}

		private static string DescribePlacementStretch(PlacementEditState state)
		{
			if (state != null)
			{
				return $"{state.StretchX:0.###},{state.StretchY:0.###}";
			}
			return "none";
		}

		private static string DescribePlacementStretch(PlacementEditSnapshot state)
		{
			if (state != null)
			{
				return $"{state.StretchX:0.###},{state.StretchY:0.###}";
			}
			return "none";
		}

		private static string DescribePlacementFlip(PlacementEditState state)
		{
			if (state != null)
			{
				return $"{state.FlipX},{state.FlipY}";
			}
			return "none";
		}

		private static string DescribePlacementFlip(PlacementEditSnapshot state)
		{
			if (state != null)
			{
				return $"{state.FlipX},{state.FlipY}";
			}
			return "none";
		}

		private static string DescribePlacementFilters(PlacementEditState state)
		{
			if (state == null)
			{
				return "none";
			}
			return $"gray={state.GrayscaleAmount:0.###},sepia={state.SepiaAmount:0.###},invert={state.InvertAmount:0.###},brightness={state.BrightnessAmount:0.###},contrast={state.ContrastAmount:0.###},saturation={state.SaturationAmount:0.###},hue={state.HueShiftAmount:0.###}";
		}

		private static string DescribePlacementFilters(PlacementEditSnapshot state)
		{
			if (state == null)
			{
				return "none";
			}
			return $"gray={state.GrayscaleAmount:0.###},sepia={state.SepiaAmount:0.###},invert={state.InvertAmount:0.###},brightness={state.BrightnessAmount:0.###},contrast={state.ContrastAmount:0.###},saturation={state.SaturationAmount:0.###},hue={state.HueShiftAmount:0.###}";
		}

		private void FitPlacementEditPreview(Texture2D texture)
		{
			//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_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_003b: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_placementEditPreviewRect == (Object)null) && !((Object)(object)_placementEditPreviewFrameRect == (Object)null) && !((Object)(object)texture == (Object)null))
			{
				Rect rect = _placementEditPreviewFrameRect.rect;
				Vector2 val = ((Rect)(ref rect)).size;
				if (val.x <= 1f || val.y <= 1f)
				{
					val = _placementEditPreviewFrameRect.sizeDelta;
				}
				float num = Mathf.Max(24f, val.x - 16f);
				float num2 = Mathf.Max(24f, val.y - 16f);
				float num3 = (float)((Texture)texture).width / Mathf.Max(1f, (float)((Texture)texture).height);
				float num4 = num;
				float num5 = num4 / Mathf.Max(0.0001f, num3);
				if (num5 > num2)
				{
					num5 = num2;
					num4 = num5 * num3;
				}
				_placementEditPreviewRect.anchorMin = new Vector2(0.5f, 0.5f);
				_placementEditPreviewRect.anchorMax = new Vector2(0.5f, 0.5f);
				_placementEditPreviewRect.pivot = new Vector2(0.5f, 0.5f);
				_placementEditPreviewRect.anchoredPosition = Vector2.zero;
				_placementEditPreviewRect.sizeDelta = new Vector2(Mathf.Clamp(num4, 8f, num), Mathf.Clamp(num5, 8f, num2));
			}
		}

		private Texture2D GetPlacementEditCheckerTexture()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_placementEditCheckerTexture != (Object)null)
			{
				return _placementEditCheckerTexture;
			}
			Texture2D val = new Texture2D(32, 32, (TextureFormat)4, false)
			{
				name = "DrawableSuitsPlacementEditChecker",
				filterMode = (FilterMode)0,
				wrapMode = (TextureWrapMode)0,
				hideFlags = (HideFlags)61
			};
			Color32 val2 = default(Color32);
			((Color32)(ref val2))..ctor((byte)18, (byte)8, (byte)8, byte.MaxValue);
			Color32 val3 = default(Color32);
			((Color32)(ref val3))..ctor((byte)42, (byte)18, (byte)18, byte.MaxValue);
			Color32[] array = (Color32[])(object)new Color32[1024];
			for (int i = 0; i < 32; i++)
			{
				for (int j = 0; j < 32; j++)
				{
					array[i * 32 + j] = (((j / 8 + i / 8) % 2 == 0) ? val2 : val3);
				}
			}
			val.SetPixels32(array);
			val.Apply(false, false);
			_placementEditCheckerTexture = val;
			return val;
		}

		private void LogPlacementEditedStampGenerated(PlacementEditTarget target, Texture2D source, PlacementEditState state, Texture2D generated, bool cacheHit)
		{
			string text = ((target == PlacementEditTarget.Decal) ? "EditedDecalFullQualityGenerated" : "PlacementEditedStampGenerated");
			DrawableSuitsDiagnostics.Info($"{text}: target={target}; source={GetPlacementEditSourceName(target)}; quality=full; sourceSize={((source != null) ? ((Texture)source).width : 0)}x{((source != null) ? ((Texture)source).height : 0)}; crop={DescribePlacementCrop(state)}; stretch={DescribePlacementStretch(state)}; flip={DescribePlacementFlip(state)}; filters={DescribePlacementFilters(state)}; cacheHit={cacheHit}; generatedSize={((generated != null) ? ((Texture)generated).width : 0)}x{((generated != null) ? ((Texture)generated).height : 0)}; suit={_selectedSuitId}");
		}

		private void LogPlacementEditPreviewSkipped(PlacementEditTarget target, string reason, string failureReason)
		{
			string text = $"skipped|target={target}|reason={reason}|failure={failureReason}";
			if (!(Time.unscaledTime - _lastPlacementEditPreviewLogTime < 0.5f) || !string.Equals(text, _lastPlacementEditPreviewLogKey, StringComparison.Ordinal))
			{
				_lastPlacementEditPreviewLogTime = Time.unscaledTime;
				_lastPlacementEditPreviewLogKey = text;
				DrawableSuitsDiagnostics.Warn($"PlacementEditPreviewSkipped: target={target}; source={GetPlacementEditSourceName(target)}; reason={reason}; failure={failureReason}; suit={_selectedSuitId}");
			}
		}

		private void LogPlacementEditPreviewUpdated(PlacementEditTarget target, Texture2D source, PlacementEditState state, Texture2D preview, string reason, bool cacheHit, bool cpuPixelSamplingUsed, float elapsedMs)
		{
			string text = (cacheHit ? "PlacementEditPreviewCacheHit" : "PlacementEditPreviewUpdated");
			string text2 = $"{text}|target={target}|reason={reason}|source={GetPlacementEditSourceName(target)}|preview={((preview != null) ? ((Texture)preview).width : 0)}x{((preview != null) ? ((Texture)preview).height : 0)}|state={state?.Revision ?? (-1)}";
			if (!cacheHit || !(Time.unscaledTime - _lastPlacementEditPreviewLogTime < 0.5f) || !string.Equals(text2, _lastPlacementEditPreviewLogKey, StringComparison.Ordinal))
			{
				_lastPlacementEditPreviewLogTime = Time.unscaledTime;
				_lastPlacementEditPreviewLogKey = text2;
				DrawableSuitsDiagnostics.Info($"{text}: target={target}; source={GetPlacementEditSourceName(target)}; reason={reason}; quality=preview; sourceSize={((source != null) ? ((Texture)source).width : 0)}x{((source != null) ? ((Texture)source).height : 0)}; generatedSize={((preview != null) ? ((Texture)preview).width : 0)}x{((preview != null) ? ((Texture)preview).height : 0)}; crop={DescribePlacementCrop(state)}; stretch={DescribePlacementStretch(state)}; flip={DescribePlacementFlip(state)}; filters={DescribePlacementFilters(state)}; cacheHit={cacheHit}; cpuPixels={cpuPixelSamplingUsed}; elapsedMs={elapsedMs:0.##}; suit={_selectedSuitId}");
			}
		}

		private void LogDecalEditPreviewFastUpdated(Texture2D source, PlacementEditState state, Texture2D preview, string reason, bool sourceCacheHit, bool textureReused, float elapsedMs)
		{
			string text = $"DecalEditPreviewFastUpdated|reason={reason}|source={GetPlacementEditSourceName(PlacementEditTarget.Decal)}|preview={((preview != null) ? ((Texture)preview).width : 0)}x{((preview != null) ? ((Texture)preview).height : 0)}|state={state?.Revision ?? (-1)}";
			if (!(Time.unscaledTime - _lastPlacementEditPreviewLogTime < 0.25f) || !string.Equals(text, _lastPlacementEditPreviewLogKey, StringComparison.Ordinal))
			{
				_lastPlacementEditPreviewLogTime = Time.unscaledTime;
				_lastPlacementEditPreviewLogKey = text;
				DrawableSuitsDiagnostics.Info($"DecalEditPreviewFastUpdated: source={GetPlacementEditSourceName(PlacementEditTarget.Decal)}; reason={reason}; quality=modalPreview; sourceSize={((source != null) ? ((Texture)source).width : 0)}x{((source != null) ? ((Texture)source).height : 0)}; previewSize={((preview != null) ? ((Texture)preview).width : 0)}x{((preview != null) ? ((Texture)preview).height : 0)}; crop={DescribePlacementCrop(state)}; stretch={DescribePlacementStretch(state)}; flip={DescribePlacementFlip(state)}; filters={DescribePlacementFilters(state)}; sourceCacheHit={sourceCacheHit}; textureReused={textureReused}; cpuPixels=True; elapsedMs={elapsedMs:0.##}; suit={_selectedSuitId}");
			}
		}

		private void LogDecalEditPreviewFastCacheHit(Texture2D source, PlacementEditState state, Texture2D preview, string reason, bool generatedPreviewCache, bool cpuPixelSamplingUsed, float elapsedMs)
		{
			string text = $"DecalEditPreviewFastCacheHit|reason={reason}|source={GetPlacementEditSourceName(PlacementEditTarget.Decal)}|preview={((preview != null) ? ((Texture)preview).width : 0)}x{((preview != null) ? ((Texture)preview).height : 0)}|state={state?.Revision ?? (-1)}";
			if (!(Time.unscaledTime - _lastPlacementEditPreviewLogTime < 0.5f) || !string.Equals(text, _lastPlacementEditPreviewLogKey, StringComparison.Ordinal))
			{
				_lastPlacementEditPreviewLogTime = Time.unscaledTime;
				_lastPlacementEditPreviewLogKey = text;
				DrawableSuitsDiagnostics.Info($"DecalEditPreviewFastCacheHit: source={GetPlacementEditSourceName(PlacementEditTarget.Decal)}; reason={reason}; quality=modalPreview; sourceSize={((source != null) ? ((Texture)source).width : 0)}x{((source != null) ? ((Texture)source).height : 0)}; previewSize={((preview != null) ? ((Texture)preview).width : 0)}x{((preview != null) ? ((Texture)preview).height : 0)}; crop={DescribePlacementCrop(state)}; stretch={DescribePlacementStretch(state)}; flip={DescribePlacementFlip(state)}; filters={DescribePlacementFilters(state)}; generatedPreviewCache={generatedPreviewCache}; cpuPixels={cpuPixelSamplingUsed}; elapsedMs={elapsedMs:0.##}; suit={_selectedSuitId}");
			}
		}

		private void LogDecalEditPreviewFastSkipped(Texture2D source, PlacementEditState state, string reason, string failureReason)
		{
			string text = $"DecalEditPreviewFastSkipped|reason={reason}|failure={failureReason}|state={state?.Revision ?? (-1)}";
			if (!(Time.unscaledTime - _lastPlacementEditPreviewLogTime < 0.5f) || !string.Equals(text, _lastPlacementEditPreviewLogKey, StringComparison.Ordinal))
			{
				_lastPlacementEditPreviewLogTime = Time.unscaledTime;
				_lastPlacementEditPreviewLogKey = text;
				DrawableSuitsDiagnostics.Warn($"DecalEditPreviewFastSkipped: source={GetPlacementEditSourceName(PlacementEditTarget.Decal)}; reason={reason}; failure={failureReason}; sourceSize={((source != null) ? ((Texture)source).width : 0)}x{((source != null) ? ((Texture)source).height : 0)}; crop={DescribePlacementCrop(state)}; stretch={DescribePlacementStretch(state)}; flip={DescribePlacementFlip(state)}; filters={DescribePlacementFilters(state)}; suit={_selectedSuitId}");
			}
		}

		private void SetSavedDesignsStatus(string message)
		{
			if ((Object)(object)_savedDesignsStatusLabel != (Object)null)
			{
				_savedDesignsStatusLabel.text = message ?? string.Empty;
			}
		}

		private void DeleteSelectedDesign()
		{
			string selectedFilePath = GetSelectedFilePath(_designFiles, _selectedDesignIndex);
			if (!TryResolveSelectedManagedFile(_designFiles, _selectedDesignIndex, DrawableSuitsPaths.Saves, ".json", out var safePath, out var failureReason))
			{
				CancelPendingDesignDelete("invalid design delete target");
				SetSavedDesignsStatus(string.IsNullOrWhiteSpace(failureReason) ? "Select a saved design first." : failureReason);
				DrawableSuitsDiagnostics.Warn(string.Format("SavedDesignDeleteRejected: selectedIndex={0}; selectedPath={1}; reason={2}", _selectedDesignIndex, selectedFilePath ?? "none", failureReason));
				return;
			}
			if (!string.Equals(_pendingDeleteDesignPath, safePath, StringComparison.OrdinalIgnoreCase))
			{
				_pendingDeleteDesignPath = safePath;
				SetSavedDesignsStatus("Press Confirm Delete to permanently delete " + Path.GetFileNameWithoutExtension(safePath) + ".");
				UpdateSavedDesignDeleteButton();
				DrawableSuitsDiagnostics.Warn($"SavedDesignDeleteArmed: file={safePath}; selectedIndex={_selectedDesignIndex}; designCount={_designFiles.Count}");
				return;
			}
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(safePath);
			try
			{
				File.Delete(safePath);
			}
			catch (Exception exception)
			{
				CancelPendingDesignDelete("design delete failed");
				SetSavedDesignsStatus("Delete failed. Check diagnostics.");
				DrawableSuitsDiagnostics.Exception($"SavedDesignDeleted failed. file={safePath}; selectedIndex={_selectedDesignIndex}", exception);
				return;
			}
			_pendingDeleteDesignPath = string.Empty;
			RefreshFileLists();
			SetSavedDesignsStatus("Deleted " + fileNameWithoutExtension + ".");
			UpdateUiState();
			RebuildSelectableNavigation();
			DrawableSuitsDiagnostics.Info($"SavedDesignDeleted: file={safePath}; designName={fileNameWithoutExtension}; designCount={_designFiles.Count}; selectedDesignIndex={_selectedDesignIndex}");
		}

		private void DeleteSelectedDecal()
		{
			string selectedFilePath = GetSelectedFilePath(_decalFiles, _selectedDecalIndex);
			if (!TryResolveSelectedManagedFile(_decalFiles, _selectedDecalIndex, DrawableSuitsPaths.Decals, null, out var safePath, out var failureReason) || !TextureTools.IsImagePath(safePath))
			{
				CancelPendingDecalDelete("invalid decal delete target");
				SetDecalsStatus(string.IsNullOrWhiteSpace(failureReason) ? "Select a decal first." : failureReason);
				DrawableSuitsDiagnostics.Warn(string.Format("DecalDeleteRejected: selectedIndex={0}; selectedPath={1}; reason={2}", _selectedDecalIndex, selectedFilePath ?? "none", failureReason));
				return;
			}
			if (!string.Equals(_pendingDeleteDecalPath, safePath, StringComparison.OrdinalIgnoreCase))
			{
				_pendingDeleteDecalPath = safePath;
				SetDecalsStatus("Press Confirm Delete to permanently delete " + Path.GetFileName(safePath) + ".");
				UpdateDecalDeleteButton();
				DrawableSuitsDiagnostics.Warn($"DecalDeleteArmed: file={safePath}; selectedIndex={_selectedDecalIndex}; decalCount={_decalFiles.Count}");
				return;
			}
			string fileName = Path.GetFileName(safePath);
			try
			{
				File.Delete(safePath);
			}
			catch (Exception exception)
			{
				CancelPendingDecalDelete("decal delete failed");
				SetDecalsStatus("Delete failed. Check diagnostics.");
				DrawableSuitsDiagnostics.Exception($"DecalDeleted failed. file={safePath}; selectedIndex={_selectedDecalIndex}", exception);
				return;
			}
			_pendingDeleteDecalPath = string.Empty;
			if ((Object)(object)_loadedDecal != (Object)null)
			{
				ClearPlacementSourcePixelCache(PlacementEditTarget.Decal, "decal deleted");
				Object.Destroy((Object)(object)_loadedDecal);
				_loadedDecal = null;
			}
			ResetPlacementEdit(PlacementEditTarget.Decal, "decal deleted", log: true);
			InvalidateDecalPreview("decal deleted");
			RefreshFileLists();
			EnsureValidToolForCurrentState("decal deleted");
			SetDecalsStatus("Deleted " + fileName + ".");
			SetStatus("Deleted decal " + fileName + ".", warn: false);
			UpdateUiState();
			RebuildSelectableNavigation();
			DrawableSuitsDiagnostics.Info($"DecalDeleted: file={safePath}; decalName={fileName}; decalCount={_decalFiles.Count}; selectedDecalIndex={_selectedDecalIndex}; loadedDecal=false; tool={_tool}");
		}

		private void UpdateSavedDesignDeleteButton()
		{
			if (!((Object)(object)_deleteSelectedDesignButton == (Object)null))
			{
				string selectedFilePath = GetSelectedFilePath(_designFiles, _selectedDesignIndex);
				bool flag = !string.IsNullOrWhiteSpace(selectedFilePath) && string.Equals(_pendingDeleteDesignPath, SafeFullPathOrEmpty(selectedFilePath), StringComparison.OrdinalIgnoreCase);
				SetButtonLabel(_deleteSelectedDesignButton, flag ? "Confirm Delete" : "Delete Selected");
				SetInteractable((Selectable)(object)_deleteSelectedDesignButton, _selectedDesignIndex >= 0 && _selectedDesignIndex < _designFiles.Count);
			}
		}

		private void UpdateDecalDeleteButton()
		{
			if (!((Object)(object)_deleteSelectedDecalButton == (Object)null))
			{
				string selectedFilePath = GetSelectedFilePath(_decalFiles, _selectedDecalIndex);
				bool flag = !string.IsNullOrWhiteSpace(selectedFilePath) && string.Equals(_pendingDeleteDecalPath, SafeFullPathOrEmpty(selectedFilePath), StringComparison.OrdinalIgnoreCase);
				SetButtonLabel(_deleteSelectedDecalButton, flag ? "Confirm Delete" : "Delete Selected");
				SetInteractable((Selectable)(object)_deleteSelectedDecalButton, _selectedDecalIndex >= 0 && _selectedDecalIndex < _decalFiles.Count);
			}
		}

		private void UpdateAddDecalButton()
		{
			if (!((Object)(object)_addDecalButton == (Object)null))
			{
				SetButtonLabel(_addDecalButton, "Copy Folder Path");
				SetInteractable((Selectable)(object)_addDecalButton, (Object)(object)_decalsPanelObject != (Object)null && _decalsPanelObject.activeSelf);
			}
		}

		private void CancelPendingFileDeletes(string reason)
		{
			CancelPendingDesignDelete(reason);
			CancelPendingDecalDelete(reason);
		}

		private void CancelPendingListDelete(string listName, string reason)
		{
			if (string.Equals(listName, "Design", StringComparison.OrdinalIgnoreCase))
			{
				CancelPendingDesignDelete(reason);
			}
			else if (string.Equals(listName, "Decal", StringComparison.OrdinalIgnoreCase))
			{
				CancelPendingDecalDelete(reason);
			}
		}

		private void CancelPendingDesignDelete(string reason)
		{
			if (!string.IsNullOrWhiteSpace(_pendingDeleteDesignPath))
			{
				string pendingDeleteDesignPath = _pendingDeleteDesignPath;
				_pendingDeleteDesignPath = string.Empty;
				UpdateSavedDesignDeleteButton();
				DrawableSuitsDiagnostics.Info("SavedDesignDeleteCanceled: reason=" + reason + "; file=" + pendingDeleteDesignPath);
			}
		}

		private void CancelPendingDecalDelete(string reason)
		{
			if (!string.IsNullOrWhiteSpace(_pendingDeleteDecalPath))
			{
				string pendingDeleteDecalPath = _pendingDeleteDecalPath;
				_pendingDeleteDecalPath = string.Empty;
				UpdateDecalDeleteButton();
				DrawableSuitsDiagnostics.Info("DecalDeleteCanceled: reason=" + reason + "; file=" + pendingDeleteDecalPath);
			}
		}

		private static bool TryResolveSelectedManagedFile(List<string> files, int index, string rootDirectory, string requiredExtension, out string safePath, out string failureReason)
		{
			safePath = null;
			failureReason = string.Empty;
			string selectedFilePath = GetSelectedFilePath(files, index);
			if (string.IsNullOrWhiteSpace(selectedFilePath))
			{
				failureReason = "Select a file first.";
				return false;
			}
			try
			{
				string fullPath = Path.GetFullPath(selectedFilePath);
				string text = Path.GetFullPath(rootDirectory);
				if (!text.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal))
				{
					text += Path.DirectorySeparatorChar;
				}
				if (!fullPath.StartsWith(text, StringComparison.OrdinalIgnoreCase))
				{
					failureReason = "Delete target is outside the DrawableSuits folder.";
					return false;
				}
				if (!string.IsNullOrWhiteSpace(requiredExtension) && !string.Equals(Path.GetExtension(fullPath), requiredExtension, StringComparison.OrdinalIgnoreCase))
				{
					failureReason = "Delete target must be a " + requiredExtension + " file.";
					return false;
				}
				if (!File.Exists(fullPath))
				{
					failureReason = "Selected file no longer exists.";
					return false;
				}
				safePath = fullPath;
				return true;
			}
			catch (Exception exception)
			{
				failureReason = "Delete target could not be validated.";
				DrawableSuitsDiagnostics.Exception("File delete target validation failed. selectedPath=" + selectedFilePath + "; root=" + rootDirectory + "; requiredExtension=" + (requiredExtension ?? "any"), exception);
				return false;
			}
		}

		private static string SafeFullPathOrEmpty(string path)
		{
			if (string.IsNullOrWhiteSpace(path))
			{
				return string.Empty;
			}
			try
			{
				return Path.GetFullPath(path);
			}
			catch
			{
				return string.Empty;
			}
		}

		private void CopyCurrentDesignCode()
		{
			DrawableSuitsDiagnostics.Info($"DesignCodeExportRequested: selectedSuitId={_selectedSuitId}; designName={_designName}");
			if (!DrawableSuitsPlugin.Registry.TryExportDesignCode(_selectedSuitId, _designName, out var code, out var info, out var failureReason))
			{
				SetDesignCodeStatus("Export failed: " + failureReason);
				DrawableSuitsDiagnostics.Warn($"DesignCodeExportFailed: selectedSuitId={_selectedSuitId}; designName={_designName}; reason={failureReason}");
				return;
			}
			if ((Object)(object)_designCodeInput != (Object)null)
			{
				_designCodeInput.text = code;
			}
			GUIUtility.systemCopyBuffer = code;
			SetDesignCodeStatus($"Code copied. Length {info.CodeLength:n0} chars.");
			DrawableSuitsDiagnostics.Info($"DesignCodeExported: format={info.FormatVersion}; designName={info.DesignName}; baseSuit={info.BaseSuitName}; sourceSuitId={info.SourceSuitId}; texture={info.Width}x{info.Height}; pngBytes={info.PngBytes}; payloadBytes={info.PayloadBytes}; jsonBytes={info.JsonBytes}; compressedBytes={info.CompressedBytes}; codeLength={info.CodeLength}");
		}

		private void PasteDesignCodeFromClipboard()
		{
			string text = GUIUtility.systemCopyBuffer ?? string.Empty;
			if ((Object)(object)_designCodeInput != (Object)null)
			{
				_designCodeInput.text = text;
			}
			SetDesignCodeStatus(string.IsNullOrWhiteSpace(text) ? "Clipboard is empty." : $"Pasted {text.Length:n0} characters.");
			DrawableSuitsDiagnostics.Info($"DesignCodePastedFromClipboard: clipboardLength={text.Length}; hasPrefix={DrawableSuitDesignCode.HasSupportedPrefix(text)}");
		}

		private void ImportDesignCodeFromField()
		{
			string text = (((Object)(object)_designCodeInput != (Object)null) ? _designCodeInput.text : string.Empty);
			DrawableSuitsDiagnostics.Info($"DesignCodeImportRequested: selectedSuitId={_selectedSuitId}; codeLength={text?.Length ?? 0}; hasPrefix={DrawableSuitDesignCode.HasSupportedPrefix(text)}; cameraBefore={_worldCameraYaw:0.##},{_worldCameraPitch:0.##},{_worldCameraDistance:0.##}");
			if (!DrawableSuitDesignCode.TryDecode(text, DrawableSuitsPlugin.ModConfig.MaxTextureSize.Value, out var payload, out var texture, out var info, out var failureReason))
			{
				SetDesignCodeStatus("Import failed: " + failureReason);
				DrawableSuitsDiagnostics.Warn($"DesignCodeImportFailed: stage=decode; selectedSuitId={_selectedSuitId}; codeLength={text?.Length ?? 0}; reason={failureReason}");
				return;
			}
			try
			{
				SaveUndo("Import code");
				if (!DrawableSuitsPlugin.Registry.ImportDecodedDesignCode(_selectedSuitId, payload, texture, out var importedDesignName, out failureReason))
				{
					DropLastUndoEntry("Import code failed");
					SetDesignCodeStatus("Import failed: " + failureReason);
					DrawableSuitsDiagnostics.Warn($"DesignCodeImportFailed: stage=apply; selectedSuitId={_selectedSuitId}; format={info.FormatVersion}; designName={info.DesignName}; sourceSuitId={info.SourceSuitId}; texture={info.Width}x{info.Height}; pngBytes={info.PngBytes}; compressedBytes={info.CompressedBytes}; codeLength={info.CodeLength}; reason={failureReason}");
					return;
				}
				_designName = importedDesignName;
				if ((Object)(object)_designNameInput != (Object)null)
				{
					_designNameInput.text = _designName;
				}
				ClearRedoHistory("design code import");
				InvalidateDecalPreview("design code import");
				InvalidateMirrorSurfaceMap("design code import");
				TryRebuildPreviewForCurrentReadiness("ImportDesignCode");
				RefreshEditorReadiness("after design code import");
				UpdateUiState();
				SetStatus("Design code imported. Press Save or Apply when ready.", warn: false);
				SetDesignCodeStatus("Imported " + importedDesignName + ". Press Save or Apply when ready.");
				DrawableSuitsDiagnostics.Info($"DesignCodeImported: format={info.FormatVersion}; designName={importedDesignName}; baseSuit={info.BaseSuitName}; sourceSuitId={info.SourceSuitId}; targetSuitId={_selectedSuitId}; texture={info.Width}x{info.Height}; pngBytes={info.PngBytes}; payloadBytes={info.PayloadBytes}; jsonBytes={info.JsonBytes}; compressedBytes={info.CompressedBytes}; codeLength={info.CodeLength}; broadcast=False; cameraAfter={_worldCameraYaw:0.##},{_worldCameraPitch:0.##},{_worldCameraDistance:0.##}");
			}
			finally
			{
				if ((Object)(object)texture != (Object)null)
				{
					Object.Destroy((Object)(object)texture);
				}
			}
		}

		private void SetDesignCodeStatus(string message)
		{
			if ((Object)(object)_designCodeStatusLabel != (Object)null)
			{
				_designCodeStatusLabel.text = message ?? string.Empty;
			}
			if (!string.IsNullOrWhiteSpace(message))
			{
				SetStatus(message, warn: false);
			}
		}

		private void CopyDecalsFolderPath()
		{
			CancelPendingDecalDelete("copy decals folder path");
			try
			{
				DrawableSuitsPaths.EnsureCreated();
				string arg = (GUIUtility.systemCopyBuffer = Path.GetFullPath(DrawableSuitsPaths.Decals));
				SetDecalsStatus("Decals folder path copied. Add PNG/JPG files there, then press Refresh.");
				SetStatus("Decals folder path copied.", warn: false);
				DrawableSuitsDiagnostics.Info($"DecalsFolderPathCopied: decalsPath={arg}; decalCount={_decalFiles.Count}; selectedDecalIndex={_selectedDecalIndex}");
			}
			catch (Exception exception)
			{
				SetDecalsStatus("Could not copy the Decals folder path.");
				SetStatus("Could not copy the Decals folder path.", warn: false);
				DrawableSuitsDiagnostics.Exception("DecalsFolderPathCopyFailed", exception);
			}
		}

		private void SelectDecal(int index)
		{
			if (index >= 0 && index < _decalFiles.Count)
			{
				CancelPendingDecalDelete("decal selection changed");
				_selectedDecalIndex = index;
				ResetPlacementEdit(PlacementEditTarget.Decal, "select decal", log: true);
				InvalidateDecalPreview("select decal");
				if ((Object)(object)_loadedDecal != (Object)null)
				{
					ClearPlacementSourcePixelCache(PlacementEditTarget.Decal, "select decal");
					Object.Destroy((Object)(object)_loadedDecal);
				}
				_loadedDecal = TextureTools.LoadImageFile(_decalFiles[index], DrawableSuitsPlugin.ModConfig.MaxTextureSize.Value);
				SetTool(EditorTool.Decal);
				CloseDecalsPanel();
				RefreshListButtons();
				UpdateUiState();
				SetStatus("Decal selected: " + Path.GetFileName(_decalFiles[index]) + ".", warn: false);
				DrawableSuitsDiagnostics.Info($"Selected decal index={index}; file={_decalFiles[index]}; loaded={(Object)(object)_loadedDecal != (Object)null}");
			}
		}

		private WorldCameraState CaptureWorldCameraState()
		{
			return new WorldCameraState
			{
				Valid = (IsWorldThirdPersonMode && (Object)(object)_worldEditorCamera != (Object)null && _worldPreviewReady),
				Yaw = _worldCameraYaw,
				Pitch = _worldCameraPitch,
				Distance = _worldCameraDistance
			};
		}

		private static bool ShouldPreserveWorldCameraState(string context, WorldCameraState state)
		{
			if (!state.Valid || string.IsNullOrWhiteSpace(context))
			{
				return false;
			}
			if (context.IndexOf("LoadSelectedDesign", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return context.IndexOf("ImportDesignCode", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private void ToggleUvFallback()
		{
			_uvFallbackMode = !_uvFallbackMode;
			DrawableSuitsDiagnostics.Info($"Texture-only fallback toggled. enabled={_uvFallbackMode}");
			TryRebuildPreviewForCurrentReadiness("ToggleUvFallback");
			RefreshEditorReadiness("after UV fallback toggle");
			UpdateUiState();
		}

		private void SetUvFallbackVisible(bool visible)
		{
			if ((Object)(object)_previewViewportRect != (Object)null)
			{
				((Component)_previewViewportRect).gameObject.SetActive(visible);
			}
			if ((Object)(object)_brushIndicator != (Object)null && !visible)
			{
				((Component)_brushIndicator).gameObject.SetActive(false);
			}
		}

		private void TryRebuildPreviewForCurrentReadiness(string context)
		{
			WorldCameraState worldCameraState = CaptureWorldCameraState();
			bool flag = ShouldPreserveWorldCameraState(context, worldCameraState);
			if ((Object)(object)((_selectedSuitId >= 0) ? DrawableSuitsPlugin.Registry.GetEditableTexture(_selectedSuitId) : null) == (Object)null)
			{
				DrawableSuitsDiagnostics.Warn($"Skipping preview setup [{context}] because no editable texture is available. hasEditableSuit={_hasEditableSuit}; selectedSuitId={_selectedSuitId}");
				DestroyPreview();
				UseTexturePreview(context, forceLog: true);
				_canPaint = false;
			}
			else if (_uvFallbackMode)
			{
				DestroyPreview();
				UseTexturePreview(context, forceLog: true);
				SetStatus("Ready. Texture-only UV panel is active. Full-suit editing.", warn: false);
			}
			else if (SetupWorldThirdPersonPreview(context, flag ? worldCameraState : default(WorldCameraState)))
			{
				RefreshTexturePanelPreview(context, forceLog: true);
			}
			else
			{
				_uvFallbackMode = true;
				DestroyPreview();
				UseTexturePreview(context, forceLog: true);
				SetStatus("Third-person setup failed; using UV fallback preview.", warn: true);
			}
		}

		private bool SetupWorldThirdPersonPreview(string context, WorldCameraState preservedCameraState = default(WorldCameraState))
		{
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Expected O, but got Unknown
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Expected O, but got Unknown
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Expected O, but got Unknown
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0411: Unknown result type (might be due to invalid IL or missing references)
			//IL_045b: Unknown result type (might be due to invalid IL or missing references)
			DestroyPreview();
			Texture2D val = ((_selectedSuitId >= 0) ? DrawableSuitsPlugin.Registry.GetEditableTexture(_selectedSuitId) : null);
			PlayerControllerB val2 = StartOfRound.Instance?.localPlayerController;
			SkinnedMeshRenderer val3 = FindBestSuitRenderer(val2);
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null)
			{
				DrawableSuitsDiagnostics.Warn("WorldThirdPerson setup skipped [" + context + "]. texture=" + DescribeEditableTexture() + "; player=" + DrawableSuitsPlugin.DescribeUnityObject((Object)(object)val2) + "; source=" + DrawableSuitsPlugin.DescribeUnityObject((Object)(object)val3));
				return false;
			}
			try
			{
				_usingTexturePreview = false;
				_previewMode = "WorldThirdPerson";
				if (preservedCameraState.Valid)
				{
					_worldCameraYaw = preservedCameraState.Yaw;
					_worldCameraPitch = preservedCameraState.Pitch;
					_worldCameraDistance = preservedCameraState.Distance;
					DrawableSuitsDiagnostics.Info($"World camera state preserved for preview rebuild. context={context}; yaw={_worldCameraYaw:0.##}; pitch={_worldCameraPitch:0.##}; distance={_worldCameraDistance:0.##}");
				}
				else
				{
					_worldCameraDistance = Mathf.Clamp(DrawableSuitsPlugin.ModConfig.ThirdPersonCameraDistance.Value, 1.5f, 8f);
					_worldCameraYaw = ((Component)val2).transform.eulerAngles.y;
					_worldCameraPitch = 12f;
					DrawableSuitsDiagnostics.Info($"World camera state initialized for preview setup. context={context}; yaw={_worldCameraYaw:0.##}; pitch={_worldCameraPitch:0.##}; distance={_worldCameraDistance:0.##}");
				}
				_worldPaintLayer = SelectWorldPaintLayer();
				_worldSourceRenderer = val3;
				_worldSourceRendererSummary = DescribeRendererCandidate(val3, "selected");
				RefreshTexturePanelPreview(context + ":world texture panel", forceLog: true);
				CaptureAndHideLocalPlayerRenderers(val2, val3);
				_worldEditorCameraObject = new GameObject("DrawableSuitsThirdPersonCamera");
				((Object)_worldEditorCameraObject).hideFlags = (HideFlags)61;
				_worldEditorCamera = _worldEditorCameraObject.AddComponent<Camera>();
				Camera main = Camera.main;
				_worldEditorCamera.depth = (((Object)(object)main != (Object)null) ? main.depth : 0f) + 50f;
				_worldEditorCamera.clearFlags = (CameraClearFlags)1;
				_worldEditorCamera.backgroundColor = (((Object)(object)main != (Object)null) ? main.backgroundColor : Color.black);
				_worldEditorCamera.fieldOfView = 62f;
				_worldEditorCamera.nearClipPlane = 0.03f;
				_worldEditorCamera.farClipPlane = 150f;
				_worldEditorCamera.cullingMask = BuildWorldEditorCameraMask(main);
				((Behaviour)_worldEditorCamera).enabled = false;
				_worldPaintProxyObject = new GameObject("DrawableSuitsWorldAvatarProxy");
				((Object)_worldPaintProxyObject).hideFlags = (HideFlags)61;
				_worldPaintProxyObject.transform.SetParent(((Component)val3).transform, false);
				_worldPaintProxyObject.layer = _worldPaintLayer;
				_worldPaintMesh = new Mesh
				{
					name = "DrawableSuitsWorldPaintMesh"
				};
				_worldAvatarMeshFilter = _worldPaintProxyObject.AddComponent<MeshFilter>();
				_worldAvatarMeshFilter.sharedMesh = _worldPaintMesh;
				_worldAvatarRenderer = _worldPaintProxyObject.AddComponent<MeshRenderer>();
				((Renderer)_worldAvatarRenderer).sharedMaterials = BuildWorldProxyMaterials(val3, forceLog: true);
				_worldPaintCollider = _worldPaintProxyObject.AddComponent<MeshCollider>();
				_worldPaintCollider.convex = false;
				_worldBrushMarker = GameObject.CreatePrimitive((PrimitiveType)0);
				((Object)_worldBrushMarker).name = "DrawableSuitsWorldBrushMarker";
				((Object)_worldBrushMarker).hideFlags = (HideFlags)61;
				_worldBrushMarker.layer = _worldPaintLayer;
				Collider component = _worldBrushMarker.GetComponent<Collider>();
				if ((Object)(object)component != (Object)null)
				{
					Object.Destroy((Object)(object)component);
				}
				Shader val4 = Shader.Find("Unlit/Color") ?? Shader.Find("Standard");
				_worldBrushMarkerMaterial = ((!((Object)(object)val4 != (Object)null)) ? ((Material)null) : new Material(val4)
				{
					name = "DrawableSuitsWorldBrushMarkerMaterial"
				});
				if ((Object)(object)_worldBrushMarkerMaterial != (Object)null)
				{
					_worldBrushMarkerMaterial.color = new Color(_brushColor.r, _brushColor.g, _brushColor.b, 0.85f);
					_worldBrushMarker.GetComponent<Renderer>().sharedMaterial = _worldBrushMarkerMaterial;
				}
				_worldBrushMarker.SetActive(false);
				bool flag = UpdateWorldPaintProxy(forceLog: true, context);
				_worldPreviewReady = flag && (Object)(object)_worldEditorCamera != (Object)null && (Object)(object)_worldPaintCollider != (Object)null;
				if (_worldPreviewReady)
				{
					UpdateWorldEditorCamera(forceLog: true);
				}
				_hasPreviewCollider = (Object)(object)_worldPaintCollider != (Object)null;
				_canPaint = (Object)(object)val != (Object)null && _worldPreviewReady;
				SetStatus(_canPaint ? "Ready. Third-person and UV panel are active." : "Third-person editor opened, but paint proxy is not ready.", !_canPaint);
				object[] obj = new object[13]
				{
					context,
					_worldPreviewReady,
					((Object)val2).name,
					_worldSourceRendererSummary,
					_rendererRestoreStates.Count,
					_worldPaintLayer,
					DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_worldEditorCamera),
					_worldEditorCamera.cullingMask,
					DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_worldPaintProxyObject),
					DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_worldAvatarRenderer),
					null,
					null,
					null
				};
				MeshRenderer worldAvatarRenderer = _worldAvatarRenderer;
				object obj2;
				if (worldAvatarRenderer == null)
				{
					obj2 = null;
				}
				else
				{
					Material sharedMaterial = ((Renderer)worldAvatarRenderer).sharedMaterial;
					obj2 = ((sharedMaterial != null) ? ((Object)sharedMaterial).name : null);
				}
				if (obj2 == null)
				{
					obj2 = "null";
				}
				obj[10] = obj2;
				obj[11] = (Object)(object)_worldPaintCollider != (Object)null;
				obj[12] = DescribeEditableTexture();
				DrawableSuitsDiagnostics.Info(string.Format("WorldThirdPerson setup complete. context={0}; ready={1}; player={2}; selectedRenderer={3}; hiddenRenderers={4}; layer={5}; camera={6}; cameraMask={7}; avatarProxy={8}; proxyRenderer={9}; proxyMaterial={10}; proxyCollider={11}; editable={12}", obj));
				return _worldPreviewReady;
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception("WorldThirdPerson setup failed. context=" + context, exception);
				DestroyWorldThirdPersonPreview(restoreRenderers: true);
				return false;
			}
		}

		private static int SelectWorldPaintLayer()
		{
			Camera main = Camera.main;
			int num = (((Object)(object)main != (Object)null) ? main.cullingMask : (-1));
			for (int num2 = 30; num2 >= 0; num2--)
			{
				if ((num & (1 << num2)) == 0)
				{
					DrawableSuitsDiagnostics.Info(string.Format("Selected world paint proxy layer {0}; mainCamera={1}; mainMask={2}", num2, ((main != null) ? ((Object)main).name : null) ?? "null", num));
					return num2;
				}
			}
			DrawableSuitsDiagnostics.Warn(string.Format("No layer outside Camera.main culling mask was available for paint proxy; using layer 2. mainCamera={0}; mainMask={1}", ((main != null) ? ((Object)main).name : null) ?? "null", num));
			return 2;
		}

		private int BuildWorldEditorCameraMask(Camera mainCamera)
		{
			int num = (((Object)(object)mainCamera != (Object)null) ? mainCamera.cullingMask : (-1));
			int num2 = 1 << _worldPaintLayer;
			int num3 = num | num2;
			DrawableSuitsDiagnostics.Info(string.Format("World editor camera mask built. mainCamera={0}; mainMask={1}; proxyLayer={2}; proxyMask={3}; finalMask={4}", ((mainCamera != null) ? ((Object)mainCamera).name : null) ?? "null", num, _worldPaintLayer, num2, num3));
			return num3;
		}

		private SkinnedMeshRenderer FindBestSuitRenderer(PlayerControllerB player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			List<SkinnedMeshRenderer> list = new List<SkinnedMeshRenderer>();
			AddRendererCandidate(list, player.thisPlayerModel);
			AddRendererCandidate(list, player.thisPlayerModelLOD1);
			AddRendererCandidate(list, player.thisPlayerModelLOD2);
			SkinnedMeshRenderer[] componentsInChildren = ((Component)player).GetComponentsInChildren<SkinnedMeshRenderer>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				AddRendererCandidate(list, componentsInChildren[i]);
			}
			SkinnedMeshRenderer val = null;
			int num = int.MinValue;
			for (int j = 0; j < list.Count; j++)
			{
				SkinnedMeshRenderer val2 = list[j];
				string reason;
				bool rejected;
				int num2 = ScoreSuitRenderer(player, val2, out reason, out rejected);
				DrawableSuitsDiagnostics.Info(string.Format("World renderer candidate: {0}; score={1}; reason={2}", DescribeRendererCandidate(val2, rejected ? "rejected" : "candidate"), num2, reason));
				if (!rejected && num2 > num)
				{
					val = val2;
					num = num2;
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				DrawableSuitsDiagnostics.Info(string.Format("World renderer selected: {0}; score={1}", DescribeRendererCandidate(val, "selected"), num));
			}
			else
			{
				DrawableSuitsDiagnostics.Warn($"No valid world suit renderer found. candidates={list.Count}");
			}
			return val;
		}

		private static void AddRendererCandidate(List<SkinnedMeshRenderer> candidates, SkinnedMeshRenderer renderer)
		{
			if ((Object)(object)renderer == (Object)null)
			{
				return;
			}
			for (int i = 0; i < candidates.Count; i++)
			{
				if (candidates[i] == renderer)
				{
					return;
				}
			}
			candidates.Add(renderer);
		}

		private int ScoreSuitRenderer(PlayerControllerB player, SkinnedMeshRenderer renderer, out string reason, out bool rejected)
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			rejected = false;
			if ((Object)(object)renderer == (Object)null)
			{
				reason = "renderer null";
				rejected = true;
				return int.MinValue;
			}
			Mesh sharedMesh = renderer.sharedMesh;
			int num = (((Object)(object)sharedMesh != (Object)null) ? sharedMesh.vertexCount : 0);
			string text = GetTransformPath(((Component)renderer).transform).ToLowerInvariant();
			if ((Object)(object)sharedMesh == (Object)null || num < 300)
			{
				reason = $"mesh missing or too small vertices={num}";
				rejected = true;
				return -10000;
			}
			if (LooksFirstPersonOnly(text))
			{
				reason = "name/path indicates first-person arms, hands, held item, camera, or viewmodel";
				rejected = true;
				return -9000 + num / 100;
			}
			Bounds bounds = ((Renderer)renderer).bounds;
			Vector3 size = ((Bounds)(ref bounds)).size;
			float num2 = Mathf.Max(size.x, Mathf.Max(size.y, size.z));
			float num3 = Mathf.Min(size.x, Mathf.Min(size.y, size.z));
			if (num2 < 0.45f || num3 < 0.02f)
			{
				reason = $"bounds too small size={size}";
				rejected = true;
				return -8000 + num / 100;
			}
			int num4 = 0;
			if (renderer == player.thisPlayerModel)
			{
				num4 += 220;
			}
			if (renderer == player.thisPlayerModelLOD1)
			{
				num4 += 160;
			}
			if (renderer == player.thisPlayerModelLOD2)
			{
				num4 += 80;
			}
			if (((Renderer)renderer).enabled)
			{
				num4 += 20;
			}
			num4 += Mathf.Clamp(num / 100, 0, 120);
			num4 += Mathf.RoundToInt(Mathf.Clamp(num2 * 25f, 0f, 90f));
			if (text.Contains("lod1"))
			{
				num4 += 70;
			}
			if (text.Contains("lod2"))
			{
				num4 += 30;
			}
			if (text.Contains("body") || text.Contains("player") || text.Contains("suit"))
			{
				num4 += 25;
			}
			if (RendererMaterialLooksCompatible((Renderer)(object)renderer))
			{
				num4 += 40;
			}
			reason = $"accepted vertices={num}; bounds={size}; materialCompatible={RendererMaterialLooksCompatible((Renderer)(object)renderer)}";
			return num4;
		}

		private static bool LooksFirstPersonOnly(string lowerPath)
		{
			if (!lowerPath.Contains("arms") && !lowerPath.Contains("arm.") && !lowerPath.Contains("/arm") && !lowerPath.Contains("hand") && !lowerPath.Contains("finger") && !lowerPath.Contains("firstperson") && !lowerPath.Contains("first person") && !lowerPath.Contains("viewmodel") && !lowerPath.Contains("view model") && !lowerPath.Contains("helmet") && !lowerPath.Contains("visor") && !lowerPath.Contains("mask") && !lowerPath.Contains("camera") && !lowerPath.Contains("held") && !lowerPath.Contains("item"))
			{
				return lowerPath.Contains("weapon");
			}
			return true;
		}

		private bool RendererMaterialLooksCompatible(Renderer renderer)
		{
			if ((Object)(object)renderer == (Object)null)
			{
				return false;
			}
			Material val = ((_selectedSuitId >= 0) ? DrawableSuitsPlugin.Registry.GetRuntimeMaterial(_selectedSuitId) : null);
			Material[] sharedMaterials = renderer.sharedMaterials;
			foreach (Material val2 in sharedMaterials)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					if ((Object)(object)val != (Object)null && val2 == val)
					{
						return true;
					}
					Texture mainTexture = val2.mainTexture;
					string text = ((Object)val2).name ?? string.Empty;
					if ((Object)(object)mainTexture != (Object)null || text.IndexOf("suit", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return true;
					}
				}
			}
			return false;
		}

		private void CaptureAndHideLocalPlayerRenderers(PlayerControllerB player, SkinnedMeshRenderer selectedSource)
		{
			RestorePlayerRenderers();
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			int num = 0;
			num += CaptureAndHideRenderer((Renderer)(object)player.thisPlayerModel, "local thisPlayerModel");
			num += CaptureAndHideRenderer((Renderer)(object)player.thisPlayerModelLOD1, "local thisPlayerModelLOD1");
			num += CaptureAndHideRenderer((Renderer)(object)player.thisPlayerModelLOD2, "local thisPlayerModelLOD2");
			num += CaptureAndHideRenderer((Renderer)(object)player.thisPlayerModelArms, "local first-person arms");
			Renderer[] componentsInChildren = ((Component)player).GetComponentsInChildren<Renderer>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				num += CaptureAndHideRenderer(componentsInChildren[i], "local player child");
			}
			Camera main = Camera.main;
			if ((Object)(object)main != (Object)null)
			{
				Renderer[] componentsInChildren2 = ((Component)main).GetComponentsInChildren<Renderer>(true);
				for (int j = 0; j < componentsInChildren2.Length; j++)
				{
					num += CaptureAndHideRenderer(componentsInChildren2[j], "local camera child");
				}
			}
			if ((Object)(object)selectedSource != (Object)null)
			{
				CaptureRendererState((Renderer)(object)selectedSource);
				selectedSource.updateWhenOffscreen = true;
				((Renderer)selectedSource).enabled = false;
			}
			num += CaptureAndHideNearbyFirstPersonOverlayRenderers(player, (Renderer)(object)selectedSource);
			DrawableSuitsDiagnostics.Info(string.Format("Hidden local renderers for third-person avatar proxy. hidden={0}; selectedSource={1}; main={2}; lod1={3}; lod2={4}; arms={5}", num, DescribeRendererCandidate(selectedSource, "selected"), DescribeRendererState((Renderer)(object)player.thisPlayerModel), DescribeRendererState((Renderer)(object)player.thisPlayerModelLOD1), DescribeRendererState((Renderer)(object)player.thisPlayerModelLOD2), DescribeRendererState((Renderer)(object)player.thisPlayerModelArms)));
		}

		private int CaptureAndHideNearbyFirstPersonOverlayRenderers(PlayerControllerB player, Renderer selectedSource)
		{
			//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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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_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_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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return 0;
			}
			int num = 0;
			Vector3 position = ((Component)player).transform.position;
			Camera main = Camera.main;
			Renderer[] array = Resources.FindObjectsOfTypeAll<Renderer>();
			foreach (Renderer val in array)
			{
				if ((Object)(object)val == (Object)null || val == selectedSource || ((Object)((Component)val).gameObject).name.IndexOf("DrawableSuits", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					continue;
				}
				Scene scene = ((Component)val).gameObject.scene;
				if (!((Scene)(ref scene)).IsValid() || !((Component)val).gameObject.activeInHierarchy)
				{
					continue;
				}
				Bounds bounds = val.bounds;
				float num2 = Vector3.Distance(((Bounds)(ref bounds)).center, position);
				float num3;
				if (!((Object)(object)main != (Object)null))
				{
					num3 = float.MaxValue;
				}
				else
				{
					bounds = val.bounds;
					num3 = Vector3.Distance(((Bounds)(ref bounds)).center, ((Component)main).transform.position);
				}
				float num4 = num3;
				if (!(num2 > 4.5f) || !(num4 > 2.5f))
				{
					string transformPath = GetTransformPath(((Component)val).transform);
					if (LooksFirstPersonOverlayRenderer(val, transformPath))
					{
						num += CaptureAndHideRenderer(val, "nearby first-person overlay path=" + transformPath);
						object[] obj = new object[4]
						{
							DescribeRendererState(val),
							num2,
							num4,
							null
						};
						Material sharedMaterial = val.sharedMaterial;
						obj[3] = ((sharedMaterial != null) ? ((Object)sharedMaterial).name : null) ?? "null";
						DrawableSuitsDiagnostics.Info(string.Format("Hidden nearby first-person overlay renderer. renderer={0}; distanceToPlayer={1:0.##}; distanceToCamera={2:0.##}; material={3}", obj));
					}
				}
			}
			return num;
		}

		private static bool LooksFirstPersonOverlayRenderer(Renderer renderer, string path)
		{
			string text = (path ?? string.Empty).ToLowerInvariant();
			if (LooksFirstPersonOnly(text) || text.Contains("local") || text.Contains("view") || text.Contains("helmet") || text.Contains("visor") || text.Contains("mask") || text.Contains("head"))
			{
				return true;
			}
			object obj;
			if (renderer == null)
			{
				obj = null;
			}
			else
			{
				Material sharedMaterial = renderer.sharedMaterial;
				obj = ((sharedMaterial != null) ? ((Object)sharedMaterial).name : null);
			}
			if (obj == null)
			{
				obj = string.Empty;
			}
			string text2 = (string)obj;
			if (text2.IndexOf("helmet", StringComparison.OrdinalIgnoreCase) < 0 && text2.IndexOf("visor", StringComparison.OrdinalIgnoreCase) < 0 && text2.IndexOf("glass", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return text2.IndexOf("view", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private int CaptureAndHideRenderer(Renderer renderer, string reason)
		{
			if ((Object)(object)renderer == (Object)null || ((Object)((Component)renderer).gameObject).name.IndexOf("DrawableSuits", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return 0;
			}
			CaptureRendererState(renderer);
			renderer.enabled = false;
			return 1;
		}

		private void CaptureRendererState(Renderer renderer)
		{
			if ((Object)(object)renderer == (Object)null)
			{
				return;
			}
			for (int i = 0; i < _rendererRestoreStates.Count; i++)
			{
				if ((Object)(object)_rendererRestoreStates[i].Renderer == (Object)(object)renderer)
				{
					return;
				}
			}
			SkinnedMeshRenderer val = (SkinnedMeshRenderer)(object)((renderer is SkinnedMeshRenderer) ? renderer : null);
			_rendererRestoreStates.Add(new RendererRestoreState
			{
				Renderer = renderer,
				Enabled = renderer.enabled,
				Layer = ((Component)renderer).gameObject.layer,
				HasUpdateWhenOffscreen = ((Object)(object)val != (Object)null),
				UpdateWhenOffscreen = ((Object)(object)val != (Object)null && val.updateWhenOffscreen)
			});
		}

		private void RestorePlayerRenderers()
		{
			for (int i = 0; i < _rendererRestoreStates.Count; i++)
			{
				RendererRestoreState rendererRestoreState = _rendererRestoreStates[i];
				if (!((Object)(object)rendererRestoreState.Renderer != (Object)null))
				{
					continue;
				}
				rendererRestoreState.Renderer.enabled = rendererRestoreState.Enabled;
				((Component)rendererRestoreState.Renderer).gameObject.layer = rendererRestoreState.Layer;
				if (rendererRestoreState.HasUpdateWhenOffscreen)
				{
					Renderer renderer = rendererRestoreState.Renderer;
					SkinnedMeshRenderer val = (SkinnedMeshRenderer)(object)((renderer is SkinnedMeshRenderer) ? renderer : null);
					if (val != null)
					{
						val.updateWhenOffscreen = rendererRestoreState.UpdateWhenOffscreen;
					}
				}
			}
			if (_rendererRestoreStates.Count > 0)
			{
				DrawableSuitsDiagnostics.Info($"Restored player renderer states. count={_rendererRestoreStates.Count}");
			}
			_rendererRestoreStates.Clear();
		}

		private static string DescribeRendererState(Renderer renderer)
		{
			if (!((Object)(object)renderer != (Object)null))
			{
				return "null";
			}
			return $"{((Object)renderer).name}:enabled={renderer.enabled}:active={((Component)renderer).gameObject.activeInHierarchy}:layer={((Component)renderer).gameObject.layer}:path={GetTransformPath(((Component)renderer).transform)}";
		}

		private static string DescribeRendererCandidate(SkinnedMeshRenderer renderer, string state)
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)renderer == (Object)null)
			{
				return state + ":null";
			}
			Mesh sharedMesh = renderer.sharedMesh;
			Material sharedMaterial = ((Renderer)renderer).sharedMaterial;
			return string.Format("{0}:{1}:path={2}:enabled={3}:active={4}:layer={5}:vertices={6}:bounds={7}:material={8}", state, ((Object)renderer).name, GetTransformPath(((Component)renderer).transform), ((Renderer)renderer).enabled, ((Component)renderer).gameObject.activeInHierarchy, ((Component)renderer).gameObject.layer, (sharedMesh != null) ? sharedMesh.vertexCount : 0, ((Renderer)renderer).bounds, ((sharedMaterial != null) ? ((Object)sharedMaterial).name : null) ?? "null");
		}

		private static string GetTransformPath(Transform transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return "null";
			}
			Stack<string> stack = new Stack<string>();
			Transform val = transform;
			while ((Object)(object)val != (Object)null)
			{
				stack.Push(((Object)val).name);
				val = val.parent;
			}
			return string.Join("/", stack);
		}

		private bool UpdateWorldPaintProxy(bool forceLog, string context = "explicit rebuild")
		{
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			SkinnedMeshRenderer val = _worldSourceRenderer ?? FindBestSuitRenderer(StartOfRound.Instance?.localPlayerController);
			if ((Object)(object)val == (Object)null || (Object)(object)_worldPaintCollider == (Object)null || (Object)(object)_worldPaintMesh == (Object)null || (Object)(object)_worldPaintProxyObject == (Object)null || (Object)(object)_worldAvatarMeshFilter == (Object)null || (Object)(object)_worldAvatarRenderer == (Object)null)
			{
				return false;
			}
			bool enabled = ((Renderer)val).enabled;
			try
			{
				_worldSourceRenderer = val;
				_worldPaintMesh.Clear();
				((Renderer)val).enabled = true;
				val.BakeMesh(_worldPaintMesh, true);
				((Renderer)val).enabled = false;
				if (_worldPaintMesh.vertexCount == 0)
				{
					if (forceLog)
					{
						DrawableSuitsDiagnostics.Warn("World paint proxy BakeMesh produced zero vertices.");
					}
					return false;
				}
				_worldPaintMesh.RecalculateBounds();
				_lastWorldProxyMeshSummary = $"mode=Full; vertices={_worldPaintMesh.vertexCount}; subMeshes={_worldPaintMesh.subMeshCount}; bounds={_worldPaintMesh.bounds}";
				if ((Object)(object)_worldPaintProxyObject.transform.parent != (Object)(object)((Component)val).transform)
				{
					_worldPaintProxyObject.transform.SetParent(((Component)val).transform, false);
				}
				_worldPaintProxyObject.transform.localPosition = Vector3.zero;
				_worldPaintProxyObject.transform.localRotation = Quaternion.identity;
				_worldPaintProxyObject.transform.localScale = Vector3.one;
				_worldPaintProxyObject.layer = _worldPaintLayer;
				_worldAvatarMeshFilter.sharedMesh = _worldPaintMesh;
				((Renderer)_worldAvatarRenderer).sharedMaterials = BuildWorldProxyMaterials(val, forceLog);
				_worldPaintCollider.sharedMesh = null;
				_worldPaintCollider.sharedMesh = _worldPaintMesh;
				((Renderer)val).enabled = false;
				if (forceLog)
				{
					object[] obj = new object[13]
					{
						context,
						_lastWorldProxyMeshSummary,
						DescribeRendererCandidate(val, "source"),
						_worldPaintMesh.vertexCount,
						_worldPaintMesh.subMeshCount,
						_worldPaintMesh.bounds,
						_worldPaintProxyObject.transform.position,
						null,
						null,
						null,
						null,
						null,
						null
					};
					Quaternion rotation = _worldPaintProxyObject.transform.rotation;
					obj[7] = ((Quaternion)(ref rotation)).eulerAngles;
					obj[8] = _worldPaintProxyObject.transform.localScale;
					obj[9] = _worldPaintLayer;
					obj[10] = ((Renderer)_worldAvatarRenderer).enabled;
					obj[11] = DescribeMaterials(((Renderer)_worldAvatarRenderer).sharedMaterials);
					obj[12] = (Object)(object)_worldPaintCollider != (Object)null;
					DrawableSuitsDiagnostics.Info(string.Format("WorldAvatarProxyRebaked: context={0}; mesh={1}; renderer={2}; vertices={3}; subMeshes={4}; bounds={5}; proxyPos={6}; proxyRot={7}; proxyScale={8}; layer={9}; rendererEnabled={10}; proxyMaterials=[{11}]; collider={12}", obj));
					DrawableSuitsDiagnostics.Info(string.Format("WorldAvatarProxyPoseFrozen: context={0}; source={1}; vertices={2}; bounds={3}; collider={4}; note=proxy mesh will not rebake during normal editor updates", context, DescribeRendererCandidate(val, "source"), _worldPaintMesh.vertexCount, _worldPaintMesh.bounds, (Object)(object)_worldPaintCollider != (Object)null));
					LogVisibleEditorCameraRenderers((Renderer)(object)val);
				}
				return true;
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception("World paint proxy update failed", exception);
				return false;
			}
			finally
			{
				if ((Object)(object)val != (Object)null)
				{
					((Renderer)val).enabled = !DrawableSuitsPlugin.IsEditorOpen && enabled;
				}
			}
		}

		private Material[] BuildWorldProxyMaterials(SkinnedMeshRenderer source, bool forceLog = false)
		{
			Material val = DrawableSuitsPlugin.Registry.GetRuntimeMaterial(_selectedSuitId) ?? ((source != null) ? ((Renderer)source).sharedMaterial : null);
			Material[] array = ((source != null) ? ((Renderer)source).sharedMaterials : null);
			int num = Mathf.Max(1, ((Object)(object)_worldPaintMesh != (Object)null) ? _worldPaintMesh.subMeshCount : ((array == null) ? 1 : array.Length));
			Material[] array2 = (Material[])(object)new Material[num];
			string[] array3 = new string[num];
			for (int i = 0; i < array2.Length; i++)
			{
				Material val2 = ((array != null && array.Length != 0) ? array[Mathf.Min(i, array.Length - 1)] : null);
				array2[i] = (MaterialLooksFirstPersonOverlay(val2) ? EnsureWorldHiddenSubmeshMaterial() : val);
				int num2 = i;
				object[] obj = new object[4]
				{
					i,
					((val2 != null) ? ((Object)val2).name : null) ?? "null",
					null,
					null
				};
				Material obj2 = array2[i];
				obj[2] = ((obj2 != null) ? ((Object)obj2).name : null) ?? "null";
				obj[3] = array2[i] == _worldHiddenSubmeshMaterial;
				array3[num2] = string.Format("{0}:{1}->{2}:hidden={3}", obj);
			}
			string text = string.Format("{0}:{1}:{2}", _selectedSuitId, ((source != null) ? ((Object)source).name : null) ?? "null", string.Join("|", array3));
			if (forceLog || !string.Equals(text, _lastWorldProxyMaterialLogKey, StringComparison.Ordinal) || Time.unscaledTime - _lastWorldProxyMaterialLogTime > 10f)
			{
				_lastWorldProxyMaterialLogKey = text;
				_lastWorldProxyMaterialLogTime = Time.unscaledTime;
				DrawableSuitsDiagnostics.Info(string.Format("World proxy materials assigned. selectedSuitId={0}; source={1}; runtime={2}; slots=[{3}]", _selectedSuitId, ((source != null) ? ((Object)source).name : null) ?? "null", ((val != null) ? ((Object)val).name : null) ?? "null", string.Join(", ", array3)));
			}
			return array2;
		}

		private Material EnsureWorldHiddenSubmeshMaterial()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0078: Expected O, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_worldHiddenSubmeshMaterial != (Object)null)
			{
				return _worldHiddenSubmeshMaterial;
			}
			Shader val = Shader.Find("Unlit/Transparent") ?? Shader.Find("UI/Default") ?? Shader.Find("Standard");
			_worldHiddenSubmeshMaterial = (((Object)(object)val != (Object)null) ? new Material(val)
			{
				name = "DrawableSuitsHiddenProxySubmesh"
			} : new Material(Shader.Find("Diffuse"))
			{
				name = "DrawableSuitsHiddenProxySubmesh"
			});
			_worldHiddenSubmeshMaterial.color = new Color(0f, 0f, 0f, 0f);
			if (_worldHiddenSubmeshMaterial.HasProperty("_Color"))
			{
				_worldHiddenSubmeshMaterial.SetColor("_Color", new Color(0f, 0f, 0f, 0f));
			}
			if (_worldHiddenSubmeshMaterial.HasProperty("_Mode"))
			{
				_worldHiddenSubmeshMaterial.SetFloat("_Mode", 3f);
			}
			if (_worldHiddenSubmeshMaterial.HasProperty("_SrcBlend"))
			{
				_worldHiddenSubmeshMaterial.SetInt("_SrcBlend", 5);
			}
			if (_worldHiddenSubmeshMaterial.HasProperty("_DstBlend"))
			{
				_worldHiddenSubmeshMaterial.SetInt("_DstBlend", 10);
			}
			if (_worldHiddenSubmeshMaterial.HasProperty("_ZWrite"))
			{
				_worldHiddenSubmeshMaterial.SetInt("_ZWrite", 0);
			}
			_worldHiddenSubmeshMaterial.renderQueue = 3000;
			return _worldHiddenSubmeshMaterial;
		}

		private static bool MaterialLooksFirstPersonOverlay(Material material)
		{
			if ((Object)(object)material == (Object)null)
			{
				return false;
			}
			string text = ((Object)material).name ?? string.Empty;
			if (text.IndexOf("helmet", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("visor", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("glass", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("arms", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("hand", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return text.IndexOf("view", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static string DescribeMaterials(Material[] materials)
		{
			if (materials == null || materials.Length == 0)
			{
				return "none";
			}
			string[] array = new string[materials.Length];
			for (int i = 0; i < materials.Length; i++)
			{
				int num = i;
				Material obj = materials[i];
				array[num] = ((obj != null) ? ((Object)obj).name : null) ?? "null";
			}
			return string.Join(", ", array);
		}

		private void LogVisibleEditorCameraRenderers(Renderer source)
		{
			//IL_0042: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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_00a9: 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_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_worldEditorCamera == (Object)null)
			{
				return;
			}
			PlayerControllerB val = StartOfRound.Instance?.localPlayerController;
			Vector3 val2 = (((Object)(object)val != (Object)null) ? ((Component)val).transform.position : ((Component)_worldEditorCamera).transform.position);
			Renderer[] array = Resources.FindObjectsOfTypeAll<Renderer>();
			int num = 0;
			for (int i = 0; i < array.Length; i++)
			{
				if (num >= 40)
				{
					break;
				}
				Renderer val3 = array[i];
				if ((Object)(object)val3 == (Object)null || !val3.enabled || !((Component)val3).gameObject.activeInHierarchy)
				{
					continue;
				}
				Scene scene = ((Component)val3).gameObject.scene;
				if (((Scene)(ref scene)).IsValid())
				{
					Bounds bounds = val3.bounds;
					if (!(Vector3.Distance(((Bounds)(ref bounds)).center, val2) > 5f) && ((_worldEditorCamera.cullingMask & (1 << ((Component)val3).gameObject.layer)) != 0 || ((Component)val3).gameObject.layer == _worldPaintLayer))
					{
						num++;
						object[] obj = new object[6]
						{
							DescribeRendererState(val3),
							GetTransformPath(((Component)val3).transform),
							val3 == source,
							((Object)((Component)val3).gameObject).name.IndexOf("DrawableSuits", StringComparison.OrdinalIgnoreCase) >= 0,
							null,
							null
						};
						bounds = val3.bounds;
						obj[4] = Vector3.Distance(((Bounds)(ref bounds)).center, val2);
						Material sharedMaterial = val3.sharedMaterial;
						obj[5] = ((sharedMaterial != null) ? ((Object)sharedMaterial).name : null) ?? "null";
						DrawableSuitsDiagnostics.Info(string.Format("World editor visible renderer candidate. renderer={0}; path={1}; source={2}; proxy={3}; distance={4:0.##}; material={5}", obj));
					}
				}
			}
		}

		private void UpdateWorldEditorCamera(bool forceLog)
		{
			//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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB val = StartOfRound.Instance?.localPlayerController;
			if (!((Object)(object)val == (Object)null) && !((Object)(object)_worldEditorCamera == (Object)null))
			{
				Vector3 val2 = ((Component)val).transform.position + Vector3.up * 1.05f;
				_worldCameraPitch = Mathf.Clamp(_worldCameraPitch, -20f, 55f);
				_worldCameraDistance = Mathf.Clamp(_worldCameraDistance, 1.5f, 8f);
				Quaternion val3 = Quaternion.Euler(_worldCameraPitch, _worldCameraYaw, 0f);
				Vector3 val4 = val2 + val3 * new Vector3(0f, 0.15f, 0f - _worldCameraDistance);
				((Component)_worldEditorCamera).transform.position = val4;
				((Component)_worldEditorCamera).transform.rotation = Quaternion.LookRotation(val2 - val4, Vector3.up);
				((Behaviour)_worldEditorCamera).enabled = _isOpen && IsWorldThirdPersonMode && _worldPreviewReady;
				if (forceLog)
				{
					DrawableSuitsDiagnostics.Info($"WorldEditorCamera updated. pos={val4}; target={val2}; yaw={_worldCameraYaw:0.##}; pitch={_worldCameraPitch:0.##}; distance={_worldCameraDistance:0.##}; depth={_worldEditorCamera.depth}; mask={_worldEditorCamera.cullingMask}");
				}
			}
		}

		private bool TryGetWorldPaintHit(out RaycastHit hit)
		{
			//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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			hit = default(RaycastHit);
			if (!IsWorldThirdPersonMode || (Object)(object)_worldEditorCamera == (Object)null || (Object)(object)_worldPaintCollider == (Object)null)
			{
				return false;
			}
			if (IsCursorOverEditorPanel())
			{
				return false;
			}
			if (!Physics.Raycast(_worldEditorCamera.ScreenPointToRay(Vector2.op_Implicit(_cursor)), ref hit, 25f, 1 << _worldPaintLayer, (QueryTriggerInteraction)1))
			{
				return false;
			}
			_lastWorldPaintUv = ((RaycastHit)(ref hit)).textureCoord;
			_lastWorldHitPoint = ((RaycastHit)(ref hit)).point;
			_lastWorldHitNormal = ((RaycastHit)(ref hit)).normal;
			return true;
		}

		private void UpdateWorldBrushMarker()
		{
			if (!((Object)(object)_worldBrushMarker == (Object)null))
			{
				_worldBrushMarker.SetActive(false);
			}
		}

		private void DestroyWorldThirdPersonPreview(bool restoreRenderers)
		{
			DestroyDecalPlacementPreviewResources();
			InvalidateMirrorSurfaceMap("destroy world third-person preview");
			if ((Object)(object)_worldEditorCamera != (Object)null)
			{
				((Behaviour)_worldEditorCamera).enabled = false;
			}
			if ((Object)(object)_worldEditorCameraObject != (Object)null)
			{
				Object.Destroy((Object)(object)_worldEditorCameraObject);
				_worldEditorCameraObject = null;
			}
			if ((Object)(object)_worldPaintProxyObject != (Object)null)
			{
				Object.Destroy((Object)(object)_worldPaintProxyObject);
				_worldPaintProxyObject = null;
			}
			if ((Object)(object)_worldPaintMesh != (Object)null)
			{
				Object.Destroy((Object)(object)_worldPaintMesh);
				_worldPaintMesh = null;
			}
			if ((Object)(object)_worldBrushMarker != (Object)null)
			{
				Object.Destroy((Object)(object)_worldBrushMarker);
				_worldBrushMarker = null;
			}
			if ((Object)(object)_worldBrushMarkerMaterial != (Object)null)
			{
				Object.Destroy((Object)(object)_worldBrushMarkerMaterial);
				_worldBrushMarkerMaterial = null;
			}
			if ((Object)(object)_worldHiddenSubmeshMaterial != (Object)null)
			{
				Object.Destroy((Object)(object)_worldHiddenSubmeshMaterial);
				_worldHiddenSubmeshMaterial = null;
			}
			_worldEditorCamera = null;
			_worldPaintCollider = null;
			_worldAvatarMeshFilter = null;
			_worldAvatarRenderer = null;
			_worldSourceRenderer = null;
			_worldSourceRendererSummary = "none";
			_worldPreviewReady = false;
			if (restoreRenderers)
			{
				RestorePlayerRenderers();
			}
		}

		private void RebuildPreview()
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Expected O, but got Unknown
			//IL_018d: 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_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Expected O, but got Unknown
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Expected O, but got Unknown
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Unknown result type (might be due to invalid IL or missing references)
			//IL_042f: Expected O, but got Unknown
			//IL_0466: Unknown result type (might be due to invalid IL or missing references)
			//IL_0486: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0742: Unknown result type (might be due to invalid IL or missing references)
			//IL_0747: Unknown result type (might be due to invalid IL or missing references)
			DestroyPreview();
			_usingTexturePreview = false;
			_previewMode = "ModelExperimentalPending";
			SkinnedMeshRenderer val = (StartOfRound.Instance?.localPlayerController)?.thisPlayerModel;
			if ((Object)(object)val == (Object)null)
			{
				SetStatus("Diagnostics: local player model not loaded; using texture preview.", warn: true);
				DrawableSuitsDiagnostics.Warn("RebuildPreview aborted: local player model is null; using texture preview.");
				UseTexturePreview("model source missing", forceLog: true);
				return;
			}
			object arg = _selectedSuitId;
			string name = ((Object)val).name;
			Mesh sharedMesh = val.sharedMesh;
			DrawableSuitsDiagnostics.Info($"RebuildPreview baking mesh. selectedSuitId={arg}; sourceRenderer={name}; verticesBeforeBake={((sharedMesh != null) ? sharedMesh.vertexCount : 0)}");
			_previewMesh = new Mesh
			{
				name = "DrawableSuitsPreviewMesh"
			};
			val.BakeMesh(_previewMesh, true);
			if (_previewMesh.vertexCount == 0)
			{
				DrawableSuitsDiagnostics.Warn("Preview BakeMesh produced zero vertices; using diagnostic fallback preview mesh.");
				Object.Destroy((Object)(object)_previewMesh);
				_previewMesh = CreateFallbackPreviewMesh();
			}
			Bounds normalizedBounds;
			Bounds val2 = NormalizePreviewMesh(_previewMesh, out normalizedBounds);
			_previewLayer = SelectPreviewLayer();
			EnsurePreviewTexture();
			_previewRigRoot = new GameObject("DrawableSuitsPreviewRig");
			((Object)_previewRigRoot).hideFlags = (HideFlags)61;
			_previewRigRoot.transform.position = new Vector3(0f, -10000f, 0f);
			_previewPivotRoot = new GameObject("DrawableSuitsPreviewMeshPivot");
			((Object)_previewPivotRoot).hideFlags = (HideFlags)61;
			_previewPivotRoot.transform.SetParent(_previewRigRoot.transform, false);
			_previewPivotRoot.transform.localPosition = Vector3.zero;
			_previewPivotRoot.transform.localRotation = Quaternion.identity;
			_previewPivotRoot.transform.localScale = Vector3.one;
			SetLayerRecursively(_previewPivotRoot, _previewLayer);
			_previewRoot = new GameObject("DrawableSuitsSuitPreviewMesh");
			((Object)_previewRoot).hideFlags = (HideFlags)61;
			_previewRoot.transform.SetParent(_previewPivotRoot.transform, false);
			_previewRoot.transform.localPosition = Vector3.zero;
			_previewRoot.transform.localRotation = Quaternion.identity;
			_previewRoot.transform.localScale = Vector3.one;
			SetLayerRecursively(_previewRoot, _previewLayer);
			_previewRoot.AddComponent<MeshFilter>().sharedMesh = _previewMesh;
			_previewRenderer = _previewRoot.AddComponent<MeshRenderer>();
			_previewMaterial = CreatePreviewMaterial();
			((Renderer)_previewRenderer).sharedMaterial = _previewMaterial;
			_previewCollider = _previewRoot.AddComponent<MeshCollider>();
			_previewCollider.sharedMesh = _previewMesh;
			GameObject val3 = new GameObject("DrawableSuitsPreviewCamera");
			((Object)val3).hideFlags = (HideFlags)61;
			val3.transform.SetParent(_previewRigRoot.transform, false);
			val3.transform.localPosition = new Vector3(0f, 0.95f, -3.2f);
			val3.transform.localRotation = Quaternion.identity;
			SetLayerRecursively(val3, _previewLayer);
			_previewCamera = val3.AddComponent<Camera>();
			((Behaviour)_previewCamera).enabled = true;
			_previewCamera.clearFlags = (CameraClearFlags)2;
			_previewCamera.backgroundColor = new Color(0.018f, 0.02f, 0.024f, 1f);
			_previewCamera.orthographic = true;
			_previewCamera.orthographicSize = CalculatePreviewOrthographicSize(_previewMesh.bounds);
			_previewCamera.nearClipPlane = 0.01f;
			_previewCamera.farClipPlane = 20f;
			_previewCamera.cullingMask = 1 << _previewLayer;
			_previewCamera.targetTexture = _previewTexture;
			if ((Object)(object)_previewMaterial != (Object)null && (Object)(object)_previewMaterial.shader != (Object)null && !((Object)_previewMaterial.shader).name.StartsWith("Unlit", StringComparison.OrdinalIgnoreCase))
			{
				GameObject val4 = new GameObject("DrawableSuitsPreviewLight");
				((Object)val4).hideFlags = (HideFlags)61;
				val4.transform.SetParent(_previewRigRoot.transform, false);
				val4.transform.localPosition = new Vector3(0f, 1.7f, -2.2f);
				val4.transform.localRotation = Quaternion.Euler(35f, -25f, 0f);
				SetLayerRecursively(val4, _previewLayer);
				_previewLight = val4.AddComponent<Light>();
				_previewLight.type = (LightType)1;
				_previewLight.intensity = 1.15f;
				_previewLight.cullingMask = 1 << _previewLayer;
			}
			_hasPreviewCollider = (Object)(object)_previewCollider != (Object)null || (Object)(object)_worldPaintCollider != (Object)null;
			_canPaint = _selectedSuitId >= 0 && (Object)(object)DrawableSuitsPlugin.Registry.GetEditableTexture(_selectedSuitId) != (Object)null;
			if (string.IsNullOrWhiteSpace(_statusMessage) || _statusMessage.StartsWith("Player model unavailable"))
			{
				SetStatus(string.Empty, warn: false);
			}
			UpdatePreviewTransform();
			RenderPreviewFrame();
			if (IsPreviewRenderTextureBlack())
			{
				DrawableSuitsDiagnostics.Warn("Experimental model preview rendered a black center sample; falling back to deterministic texture preview.");
				DestroyPreview();
				UseTexturePreview("black RenderTexture fallback", forceLog: true);
				return;
			}
			_usingTexturePreview = false;
			_previewMode = "ModelExperimental";
			object[] obj = new object[16]
			{
				_previewMesh.vertexCount, val2, normalizedBounds, _previewMesh.bounds, _previewLayer, null, null, null, null, null,
				null, null, null, null, null, null
			};
			Camera main = Camera.main;
			obj[5] = ((main != null) ? main.cullingMask.ToString() : null) ?? "null";
			obj[6] = ((Behaviour)_previewCamera).enabled;
			obj[7] = _previewCamera.cullingMask;
			obj[8] = (Object)(object)_previewCollider != (Object)null;
			Material sharedMaterial = ((Renderer)_previewRenderer).sharedMaterial;
			obj[9] = ((sharedMaterial != null) ? ((Object)sharedMaterial).name : null) ?? "null";
			Material sharedMaterial2 = ((Renderer)_previewRenderer).sharedMaterial;
			object obj2;
			if (sharedMaterial2 == null)
			{
				obj2 = null;
			}
			else
			{
				Shader shader = sharedMaterial2.shader;
				obj2 = ((shader != null) ? ((Object)shader).name : null);
			}
			if (obj2 == null)
			{
				obj2 = "null";
			}
			obj[10] = obj2;
			RenderTexture previewTexture = _previewTexture;
			obj[11] = ((previewTexture != null) ? new int?(((Texture)previewTexture).width) : ((int?)null));
			RenderTexture previewTexture2 = _previewTexture;
			obj[12] = ((previewTexture2 != null) ? new int?(((Texture)previewTexture2).height) : ((int?)null));
			RenderTexture previewTexture3 = _previewTexture;
			obj[13] = ((previewTexture3 != null) ? previewTexture3.IsCreated().ToString() : null) ?? "null";
			obj[14] = DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_previewCamera);
			obj[15] = (((Object)(object)_previewViewportRect != (Object)null) ? ((object)_previewViewportRect.rect/*cast due to .constrained prefix*/).ToString() : "null");
			DrawableSuitsDiagnostics.Info(string.Format("RebuildPreview complete. meshVertices={0}; bakedBounds={1}; normalizedBounds={2}; finalMeshBounds={3}; previewLayer={4}; mainCameraMask={5}; cameraEnabled={6}; cameraMask={7}; collider={8}; material={9}; shader={10}; renderTexture={11}x{12}; rtCreated={13}; previewCamera={14}; viewport={15}", obj));
		}

		private static Mesh CreateFallbackPreviewMesh()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_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_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: 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_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			Mesh val = new Mesh
			{
				name = "DrawableSuitsFallbackPreviewMesh"
			};
			val.vertices = (Vector3[])(object)new Vector3[8]
			{
				new Vector3(-0.45f, -0.75f, -0.12f),
				new Vector3(0.45f, -0.75f, -0.12f),
				new Vector3(0.45f, 0.75f, -0.12f),
				new Vector3(-0.45f, 0.75f, -0.12f),
				new Vector3(-0.45f, -0.75f, 0.12f),
				new Vector3(0.45f, -0.75f, 0.12f),
				new Vector3(0.45f, 0.75f, 0.12f),
				new Vector3(-0.45f, 0.75f, 0.12f)
			};
			val.triangles = new int[36]
			{
				0, 2, 1, 0, 3, 2, 4, 5, 6, 4,
				6, 7, 0, 1, 5, 0, 5, 4, 1, 2,
				6, 1, 6, 5, 2, 3, 7, 2, 7, 6,
				3, 0, 4, 3, 4, 7
			};
			val.uv = (Vector2[])(object)new Vector2[8]
			{
				new Vector2(0f, 0f),
				new Vector2(1f, 0f),
				new Vector2(1f, 1f),
				new Vector2(0f, 1f),
				new Vector2(0f, 0f),
				new Vector2(1f, 0f),
				new Vector2(1f, 1f),
				new Vector2(0f, 1f)
			};
			val.RecalculateNormals();
			val.RecalculateBounds();
			return val;
		}

		private static Bounds NormalizePreviewMesh(Mesh mesh, out Bounds normalizedBounds)
		{
			//IL_0001: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			normalizedBounds = default(Bounds);
			if ((Object)(object)mesh == (Object)null || mesh.vertexCount == 0)
			{
				return default(Bounds);
			}
			Bounds bounds = mesh.bounds;
			Vector3[] vertices = mesh.vertices;
			Vector3 center = ((Bounds)(ref bounds)).center;
			for (int i = 0; i < vertices.Length; i++)
			{
				ref Vector3 reference = ref vertices[i];
				reference -= center;
			}
			mesh.vertices = vertices;
			mesh.RecalculateBounds();
			Bounds bounds2 = mesh.bounds;
			Vector3 center2 = ((Bounds)(ref bounds2)).center;
			if (((Vector3)(ref center2)).sqrMagnitude > 0.0001f)
			{
				vertices = mesh.vertices;
				Vector3 center3 = ((Bounds)(ref bounds2)).center;
				for (int j = 0; j < vertices.Length; j++)
				{
					ref Vector3 reference2 = ref vertices[j];
					reference2 -= center3;
				}
				mesh.vertices = vertices;
				mesh.RecalculateBounds();
			}
			try
			{
				mesh.RecalculateNormals();
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception("Preview mesh normal recalculation failed", exception);
			}
			normalizedBounds = mesh.bounds;
			Vector3 size = ((Bounds)(ref normalizedBounds)).size;
			if (size.x < 0.01f)
			{
				size.x = 0.01f;
			}
			if (size.y < 0.01f)
			{
				size.y = 0.01f;
			}
			if (size.z < 0.01f)
			{
				size.z = 0.01f;
			}
			mesh.bounds = new Bounds(Vector3.zero, size);
			normalizedBounds = mesh.bounds;
			return bounds;
		}

		private static int SelectPreviewLayer()
		{
			Camera main = Camera.main;
			int num = (((Object)(object)main != (Object)null) ? main.cullingMask : (-1));
			for (int num2 = 30; num2 >= 0; num2--)
			{
				if ((num & (1 << num2)) == 0)
				{
					DrawableSuitsDiagnostics.Info(string.Format("Selected preview layer {0}; mainCamera={1}; mainMask={2}", num2, ((main != null) ? ((Object)main).name : null) ?? "null", num));
					return num2;
				}
			}
			DrawableSuitsDiagnostics.Warn(string.Format("No layer outside Camera.main culling mask was available; using layer 2 with normalized off-screen preview rig. mainCamera={0}; mainMask={1}", ((main != null) ? ((Object)main).name : null) ?? "null", num));
			return 2;
		}

		private static float CalculatePreviewOrthographicSize(Bounds bounds)
		{
			//IL_0007: 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)
			float num = Mathf.Max(0.25f, ((Bounds)(ref bounds)).extents.y);
			float num2 = Mathf.Max(0.25f, ((Bounds)(ref bounds)).extents.x);
			float num3 = 7f / 9f;
			float num4 = num2 / Mathf.Max(0.1f, num3);
			return Mathf.Clamp(Mathf.Max(num, num4) * 1.35f, 0.75f, 6f);
		}

		private void EnsurePreviewTexture()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_previewTexture != (Object)null))
			{
				_previewTexture = new RenderTexture(768, 768, 16, (RenderTextureFormat)0)
				{
					name = "DrawableSuitsPreviewTexture",
					antiAliasing = 2
				};
				_previewTexture.Create();
				if ((Object)(object)_previewImage != (Object)null)
				{
					((RawImage)_previewImage).texture = (Texture)(object)_previewTexture;
					((RawImage)_previewImage).uvRect = new Rect(0f, 0f, 1f, 1f);
					((Graphic)_previewImage).color = Color.white;
				}
			}
		}

		private Texture2D EnsureCheckerTexture()
		{
			//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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_0089: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_checkerTexture != (Object)null)
			{
				return _checkerTexture;
			}
			_checkerTexture = new Texture2D(32, 32, (TextureFormat)4, false)
			{
				name = "DrawableSuitsCheckerTexture",
				filterMode = (FilterMode)0,
				wrapMode = (TextureWrapMode)0,
				hideFlags = (HideFlags)61
			};
			Color32 val = default(Color32);
			((Color32)(ref val))..ctor((byte)22, (byte)25, (byte)29, byte.MaxValue);
			Color32 val2 = default(Color32);
			((Color32)(ref val2))..ctor((byte)42, (byte)46, (byte)52, byte.MaxValue);
			for (int i = 0; i < ((Texture)_checkerTexture).height; i++)
			{
				for (int j = 0; j < ((Texture)_checkerTexture).width; j++)
				{
					_checkerTexture.SetPixel(j, i, Color32.op_Implicit(((j / 8 + i / 8) % 2 == 0) ? val : val2));
				}
			}
			_checkerTexture.Apply(false, true);
			return _checkerTexture;
		}

		private void UseTexturePreview(string context, bool forceLog)
		{
			Texture2D val = ((_selectedSuitId >= 0) ? DrawableSuitsPlugin.Registry.GetEditableTexture(_selectedSuitId) : null);
			_usingTexturePreview = true;
			_previewMode = (((Object)(object)val != (Object)null) ? "TextureFallback" : "TextureFallbackNoEditableTexture");
			_canPaint = (Object)(object)val != (Object)null;
			RefreshTexturePanelPreview(context, forceLog);
		}

		private bool RefreshTexturePanelPreview(string context, bool forceLog)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = ((_selectedSuitId >= 0) ? DrawableSuitsPlugin.Registry.GetEditableTexture(_selectedSuitId) : null);
			Texture val2 = (Texture)(object)(((Object)(object)val != (Object)null) ? val : EnsureCheckerTexture());
			bool flag = (Object)(object)val != (Object)null || _usingTexturePreview || _uvFallbackMode;
			SetUvFallbackVisible(flag);
			if ((Object)(object)_previewImage != (Object)null)
			{
				((RawImage)_previewImage).texture = val2;
				if ((Object)(object)val != (Object)null)
				{
					EnsureUvPanelViewForTexture(val, context);
				}
				ApplyUvPanelViewToPreviewImage(val);
				((Graphic)_previewImage).color = Color.white;
				((Graphic)_previewImage).raycastTarget = true;
			}
			string text = (IsWorldThirdPersonMode ? "TexturePanel" : _previewMode);
			Rect uvPanelViewRect = GetUvPanelViewRect();
			string text2 = string.Format("{0}; visible={1}; assigned={2}; editable={3}; rawImage={4}; uvZoom={5:0.###}; uvCenter={6}; uvRotation={7}; uvRect={8}", text, flag, ((val2 != null) ? ((Object)val2).name : null) ?? "null", DescribeEditableTexture(), DescribePreviewImageTexture(), _uvPanelZoom, _uvPanelCenter, UvPanelRotationDegrees(_uvPanelRotationQuarterTurns), uvPanelViewRect);
			if (forceLog || !string.Equals(_lastPreviewAssignmentLog, text2, StringComparison.Ordinal))
			{
				DrawableSuitsDiagnostics.Info("TexturePanel[" + context + "]: " + text2 + "; viewport=" + (((Object)(object)_previewViewportRect != (Object)null) ? ((object)_previewViewportRect.rect/*cast due to .constrained prefix*/).ToString() : "null") + "; siblingIndex=" + (((Object)(object)_previewViewportRect != (Object)null) ? ((Transform)_previewViewportRect).GetSiblingIndex().ToString() : "null") + "; anchoredPosition=" + (((Object)(object)_previewViewportRect != (Object)null) ? ((object)_previewViewportRect.anchoredPosition/*cast due to .constrained prefix*/).ToString() : "null"));
				_lastPreviewAssignmentLog = text2;
			}
			return (Object)(object)val != (Object)null;
		}

		private string DescribeEditableTexture()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = ((_selectedSuitId >= 0) ? DrawableSuitsPlugin.Registry.GetEditableTexture(_selectedSuitId) : null);
			if ((Object)(object)val == (Object)null)
			{
				return "null";
			}
			return $"{((Object)val).name} {((Texture)val).width}x{((Texture)val).height} {val.format}";
		}

		private string DescribePreviewImageTexture()
		{
			Texture val = (((Object)(object)_previewImage != (Object)null) ? ((RawImage)_previewImage).texture : null);
			if (!((Object)(object)val != (Object)null))
			{
				return "null";
			}
			return $"{((Object)val).name} {val.width}x{val.height}";
		}

		private bool IsPreviewRenderTextureBlack()
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: 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_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_previewTexture == (Object)null || !_previewTexture.IsCreated())
			{
				return true;
			}
			int num = Mathf.Min(96, ((Texture)_previewTexture).width);
			int num2 = Mathf.Min(96, ((Texture)_previewTexture).height);
			int num3 = Mathf.Max(0, (((Texture)_previewTexture).width - num) / 2);
			int num4 = Mathf.Max(0, (((Texture)_previewTexture).height - num2) / 2);
			RenderTexture active = RenderTexture.active;
			Texture2D val = null;
			try
			{
				RenderTexture.active = _previewTexture;
				val = new Texture2D(num, num2, (TextureFormat)4, false);
				val.ReadPixels(new Rect((float)num3, (float)num4, (float)num, (float)num2), 0, 0, false);
				val.Apply(false, false);
				Color32[] pixels = val.GetPixels32();
				for (int i = 0; i < pixels.Length; i++)
				{
					Color32 val2 = pixels[i];
					if (val2.a > 8 && val2.r + val2.g + val2.b > 28)
					{
						DrawableSuitsDiagnostics.Info($"Experimental model preview readback found non-black pixel at index={i}; color=({val2.r},{val2.g},{val2.b},{val2.a}).");
						return false;
					}
				}
				DrawableSuitsDiagnostics.Warn($"Experimental model preview readback was black. sampleRect=({num3},{num4},{num},{num2}); renderTexture={((Texture)_previewTexture).width}x{((Texture)_previewTexture).height}; camera={DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_previewCamera)}; layer={_previewLayer}");
				return true;
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception("Experimental model preview black-frame readback failed", exception);
				return false;
			}
			finally
			{
				RenderTexture.active = active;
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)val);
				}
			}
		}

		private Material CreatePreviewMaterial()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			Material runtimeMaterial = DrawableSuitsPlugin.Registry.GetRuntimeMaterial(_selectedSuitId);
			Shader val = Shader.Find("Unlit/Texture") ?? Shader.Find("Unlit/Transparent") ?? Shader.Find("Standard");
			Material val2 = (((Object)(object)val != (Object)null) ? new Material(val)
			{
				name = "DrawableSuitsPreviewMaterial"
			} : ((!((Object)(object)runtimeMaterial != (Object)null)) ? new Material(Shader.Find("Diffuse"))
			{
				name = "DrawableSuitsPreviewMaterial"
			} : new Material(runtimeMaterial)
			{
				name = "DrawableSuitsPreviewMaterial"
			}));
			Texture2D val3 = DrawableSuitsPlugin.Registry.GetEditableTexture(_selectedSuitId);
			if ((Object)(object)val3 == (Object)null)
			{
				Texture obj = ((runtimeMaterial != null) ? runtimeMaterial.mainTexture : null);
				val3 = (Texture2D)(object)((obj is Texture2D) ? obj : null);
			}
			val2.mainTexture = (Texture)(object)val3;
			val2.color = Color.white;
			if (val2.HasProperty("_Cull"))
			{
				val2.SetInt("_Cull", 0);
			}
			return val2;
		}

		private static void SetLayerRecursively(GameObject target, int layer)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			if ((Object)(object)target == (Object)null)
			{
				return;
			}
			target.layer = layer;
			foreach (Transform item in target.transform)
			{
				Transform val = item;
				if ((Object)(object)val != (Object)null)
				{
					SetLayerRecursively(((Component)val).gameObject, layer);
				}
			}
		}

		private void UpdatePreviewTransform()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_0056: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_previewPivotRoot == (Object)null) && !((Object)(object)_previewRoot == (Object)null) && !((Object)(object)_previewMesh == (Object)null))
			{
				Bounds bounds = _previewMesh.bounds;
				float num = Mathf.Max(0.01f, Mathf.Max(((Bounds)(ref bounds)).size.x, Mathf.Max(((Bounds)(ref bounds)).size.y, ((Bounds)(ref bounds)).size.z)));
				_previewPivotRoot.transform.localPosition = Vector3.zero;
				_previewPivotRoot.transform.localRotation = Quaternion.identity;
				_previewPivotRoot.transform.localScale = Vector3.one * _previewScale;
				_previewRoot.transform.localPosition = Vector3.zero;
				_previewRoot.transform.localRotation = Quaternion.identity;
				_previewRoot.transform.localScale = Vector3.one;
				if ((Object)(object)_previewCamera != (Object)null)
				{
					float num2 = Mathf.Clamp(num * 2.4f, 3.2f, 12f);
					((Component)_previewCamera).transform.localPosition = new Vector3(0f, 0f, 0f - num2);
					((Component)_previewCamera).transform.localRotation = Quaternion.identity;
					_previewCamera.orthographicSize = CalculatePreviewOrthographicSize(bounds) / Mathf.Max(0.2f, _previewScale);
					((Behaviour)_previewCamera).enabled = true;
				}
			}
		}

		private void RenderPreviewFrame()
		{
			if ((Object)(object)_previewCamera == (Object)null || (Object)(object)_previewTexture == (Object)null)
			{
				return;
			}
			if (!_previewTexture.IsCreated())
			{
				_previewTexture.Create();
			}
			((Behaviour)_previewCamera).enabled = true;
			_previewCamera.targetTexture = _previewTexture;
			_previewCamera.cullingMask = 1 << _previewLayer;
			RenderTexture active = RenderTexture.active;
			try
			{
				_previewCamera.Render();
			}
			catch (Exception exception)
			{
				DrawableSuitsDiagnostics.Exception("Preview camera Render failed", exception);
			}
			finally
			{
				RenderTexture.active = active;
			}
		}

		private void DestroyPreview()
		{
			//IL_0105: 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)
			DestroyWorldThirdPersonPreview(restoreRenderers: true);
			if ((Object)(object)_previewRoot != (Object)null)
			{
				Object.Destroy((Object)(object)_previewRoot);
				_previewRoot = null;
			}
			if ((Object)(object)_previewCamera != (Object)null)
			{
				((Behaviour)_previewCamera).enabled = false;
			}
			if ((Object)(object)_previewRigRoot != (Object)null)
			{
				Object.Destroy((Object)(object)_previewRigRoot);
				_previewRigRoot = null;
			}
			_previewPivotRoot = null;
			if ((Object)(object)_previewMesh != (Object)null)
			{
				Object.Destroy((Object)(object)_previewMesh);
				_previewMesh = null;
			}
			if ((Object)(object)_previewMaterial != (Object)null)
			{
				Object.Destroy((Object)(object)_previewMaterial);
				_previewMaterial = null;
			}
			if ((Object)(object)_previewTexture != (Object)null)
			{
				if ((Object)(object)_previewImage != (Object)null && (object)((RawImage)_previewImage).texture == _previewTexture)
				{
					((RawImage)_previewImage).texture = (Texture)(object)EnsureCheckerTexture();
					((RawImage)_previewImage).uvRect = new Rect(0f, 0f, 10f, 10f);
					((Graphic)_previewImage).color = Color.white;
				}
				_previewTexture.Release();
				Object.Destroy((Object)(object)_previewTexture);
				_previewTexture = null;
			}
			_previewCollider = null;
			_previewRenderer = null;
			_previewCamera = null;
			_previewLight = null;
			_hasPreviewCollider = false;
			_canPaint = (Object)(object)DrawableSuitsPlugin.Registry != (Object)null && _selectedSuitId >= 0 && (Object)(object)DrawableSuitsPlugin.Registry.GetEditableTexture(_selectedSuitId) != (Object)null;
		}

		private void LogCanvasState(string context)
		{
			//IL_005d: 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_0066: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_editorCanvasObject == (Object)null)
			{
				DrawableSuitsDiagnostics.Warn("CanvasState[" + context + "]: editorCanvasObject=null");
				return;
			}
			Canvas component = _editorCanvasObject.GetComponent<Canvas>();
			GraphicRaycaster component2 = _editorCanvasObject.GetComponent<GraphicRaycaster>();
			EventSystem val = Object.FindObjectOfType<EventSystem>();
			object obj;
			Rect rect;
			if (!((Object)(object)_panelRect != (Object)null))
			{
				obj = "null";
			}
			else
			{
				rect = _panelRect.rect;
				obj = ((object)((Rect)(ref rect)).size/*cast due to .constrained prefix*/).ToString();
			}
			string text = (string)obj;
			object obj2;
			if (!((Object)(object)_previewViewportRect != (Object)null))
			{
				obj2 = "null";
			}
			else
			{
				rect = _previewViewportRect.rect;
				obj2 = ((object)((Rect)(ref rect)).size/*cast due to .constrained prefix*/).ToString();
			}
			string text2 = (string)obj2;
			object obj3;
			if (!((Object)(object)_canvasRect != (Object)null))
			{
				obj3 = "null";
			}
			else
			{
				rect = _canvasRect.rect;
				obj3 = ((object)((Rect)(ref rect)).size/*cast due to .constrained prefix*/).ToString();
			}
			string text3 = (string)obj3;
			EventSystem current = EventSystem.current;
			BaseInputModule val2 = ((current != null) ? current.currentInputModule : null);
			object[] obj4 = new object[14]
			{
				context,
				_editorCanvasObject.activeSelf,
				_editorCanvasObject.activeInHierarchy,
				((component != null) ? ((object)component.renderMode/*cast due to .constrained prefix*/).ToString() : null) ?? "null",
				((component != null) ? component.sortingOrder.ToString() : null) ?? "null",
				_editorCanvasObject.transform.childCount,
				text3,
				text,
				text2,
				(Object)(object)component2 != (Object)null && ((Behaviour)component2).enabled,
				((val != null) ? ((Object)val).name : null) ?? "null",
				null,
				null,
				null
			};
			EventSystem current2 = EventSystem.current;
			obj4[11] = ((current2 != null) ? ((Object)current2).name : null) ?? "null";
			obj4[12] = ((object)val2)?.GetType().Name ?? "null";
			EventSystem current3 = EventSystem.current;
			object obj5;
			if (current3 == null)
			{
				obj5 = null;
			}
			else
			{
				GameObject currentSelectedGameObject = current3.currentSelectedGameObject;
				obj5 = ((currentSelectedGameObject != null) ? ((Object)currentSelectedGameObject).name : null);
			}
			if (obj5 == null)
			{
				obj5 = "null";
			}
			obj4[13] = obj5;
			DrawableSuitsDiagnostics.Info(string.Format("CanvasState[{0}]: activeSelf={1}; activeInHierarchy={2}; canvasMode={3}; sortingOrder={4}; childCount={5}; canvasSize={6}; panelSize={7}; previewSize={8}; raycaster={9}; eventSystem={10}; current={11}; inputModule={12}; currentSelected={13}", obj4));
		}

		private unsafe void LogUiInputDiagnosticsIfNeeded()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			if (Time.unscaledTime - _lastUiDiagnosticsTime < 1f)
			{
				return;
			}
			_lastUiDiagnosticsTime = Time.unscaledTime;
			Vector2 cursor = _cursor;
			bool flag = string.Equals(_pointerSource, "Mouse", StringComparison.OrdinalIgnoreCase);
			string text = "none";
			GraphicRaycaster val = (((Object)(object)_editorCanvasObject != (Object)null) ? _editorCanvasObject.GetComponent<GraphicRaycaster>() : null);
			if ((Object)(object)val != (Object)null && (Object)(object)EventSystem.current != (Object)null)
			{
				PointerEventData val2 = new PointerEventData(EventSystem.current)
				{
					position = cursor
				};
				List<RaycastResult> list = new List<RaycastResult>();
				((BaseRaycaster)val).Raycast(val2, list);
				if (list.Count > 0)
				{
					List<string> list2 = new List<string>();
					for (int i = 0; i < list.Count && i < 6; i++)
					{
						RaycastResult val3 = list[i];
						object item;
						if (!((Object)(object)((RaycastResult)(ref val3)).gameObject != (Object)null))
						{
							item = "null";
						}
						else
						{
							val3 = list[i];
							item = ((Object)((RaycastResult)(ref val3)).gameObject).name;
						}
						list2.Add((string)item);
					}
					text = string.Join(", ", list2);
				}
			}
			EventSystem current = EventSystem.current;
			BaseInputModule val4 = ((current != null) ? current.currentInputModule : null);
			Vector2 uv;
			string text2 = (TryGetTexturePreviewUv(cursor, out uv) ? ((object)(*(Vector2*)(&uv))/*cast due to .constrained prefix*/).ToString() : "none");
			object[] array = new object[30];
			EventSystem current2 = EventSystem.current;
			array[0] = ((current2 != null) ? ((Object)current2).name : null) ?? "null";
			array[1] = ((object)val4)?.GetType().Name ?? "null";
			EventSystem current3 = EventSystem.current;
			object obj;
			if (current3 == null)
			{
				obj = null;
			}
			else
			{
				GameObject currentSelectedGameObject = current3.currentSelectedGameObject;
				obj = ((currentSelectedGameObject != null) ? ((Object)currentSelectedGameObject).name : null);
			}
			if (obj == null)
			{
				obj = "null";
			}
			array[2] = obj;
			array[3] = _pointerSource;
			array[4] = cursor;
			array[5] = flag;
			array[6] = _mousePositionAvailable;
			array[7] = _lastMousePosition;
			array[8] = _lastGamepadStick;
			array[9] = _cursor;
			array[10] = Cursor.visible;
			array[11] = Cursor.lockState;
			GameObject editorCanvasObject = _editorCanvasObject;
			object obj2;
			if (editorCanvasObject == null)
			{
				obj2 = null;
			}
			else
			{
				Canvas component = editorCanvasObject.GetComponent<Canvas>();
				obj2 = ((component != null) ? component.scaleFactor.ToString("0.###") : null);
			}
			if (obj2 == null)
			{
				obj2 = "null";
			}
			array[12] = obj2;
			array[13] = text;
			array[14] = IsCursorOverEditorPanel();
			array[15] = IsCursorOverPreviewViewport();
			array[16] = text2;
			array[17] = (_lastPreviewUvAvailable ? ((object)Unsafe.As<Vector2, Vector2>(ref _lastPreviewUv)/*cast due to .constrained prefix*/).ToString() : "none");
			array[18] = _previewMode;
			array[19] = _uvPanelZoom;
			array[20] = UvPanelRotationDegrees(_uvPanelRotationQuarterTurns);
			array[21] = GetUvPanelViewRect();
			array[22] = DescribeEditableTexture();
			array[23] = DescribePreviewImageTexture();
			array[24] = (((Object)(object)_previewViewportRect != (Object)null) ? ((object)_previewViewportRect.rect/*cast due to .constrained prefix*/).ToString() : "null");
			array[25] = DrawableSuitsPlugin.DescribeUnityObject((Object)(object)_previewCamera);
			Camera previewCamera = _previewCamera;
			array[26] = ((previewCamera != null) ? ((Behaviour)previewCamera).enabled.ToString() : null) ?? "null";
			array[27] = _previewLayer;
			RenderTexture previewTexture = _previewTexture;
			array[28] = ((previewTexture != null) ? ((Texture)previewTexture).width.ToString() : null) ?? "null";
			RenderTexture previewTexture2 = _previewTexture;
			array[29] = ((previewTexture2 != null) ? ((Texture)previewTexture2).height.ToString() : null) ?? "null";
			DrawableSuitsDiagnostics.Info(string.Format("UiInputDiagnostics: currentEventSystem={0}; activeModule={1}; selected={2}; pointerSource={3}; pointer={4}; usingMousePointer={5}; mouseAvailable={6}; mousePosition={7}; gamepadStick={8}; virtualCursor={9}; cursorVisible={10}; cursorLock={11}; canvasScale={12}; raycastHits=[{13}]; overPanel={14}; overPreview={15}; previewUv={16}; lastPreviewUv={17}; previewMode={18}; uvPanelZoom={19:0.###}; uvPanelRotation={20}; uvPanelRect={21}; editableTexture={22}; previewImageTexture={23}; previewRect={24}; previewCamera={25}; previewCameraEnabled={26}; previewLayer={27}; renderTexture={28}x{29}", array));
		}

		private static void LogEditorControlTree(Transform root)
		{
			//IL_0066: 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_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			int num = 0;
			RectTransform[] componentsInChildren = ((Component)root).GetComponentsInChildren<RectTransform>(true);
			foreach (RectTransform val in componentsInChildren)
			{
				if (num < 32)
				{
					Text component = ((Component)val).GetComponent<Text>();
					Image component2 = ((Component)val).GetComponent<Image>();
					Selectable component3 = ((Component)val).GetComponent<Selectable>();
					CanvasRenderer component4 = ((Component)val).GetComponent<CanvasRenderer>();
					string text = (((Object)(object)component != (Object)null) ? $"; text='{component.text}'; textColor={((Graphic)component).color}; fontSize={component.fontSize}" : string.Empty);
					string text2 = (((Object)(object)component2 != (Object)null) ? $"; imageColor={((Graphic)component2).color}" : string.Empty);
					string text3 = (((Object)(object)component3 != (Object)null) ? $"; selectable={((object)component3).GetType().Name}; interactable={component3.interactable}" : string.Empty);
					string text4 = (((Object)(object)component4 != (Object)null) ? $"; alpha={component4.GetAlpha():0.###}" : string.Empty);
					object[] obj = new object[12]
					{
						num,
						((Object)val).name,
						((Component)val).gameObject.activeSelf,
						((Component)val).gameObject.activeInHierarchy,
						val.anchorMin,
						val.anchorMax,
						val.anchoredPosition,
						null,
						null,
						null,
						null,
						null
					};
					Rect rect = val.rect;
					obj[7] = ((Rect)(ref rect)).size;
					obj[8] = text4;
					obj[9] = text;
					obj[10] = text2;
					obj[11] = text3;
					DrawableSuitsDiagnostics.Info(string.Format("EditorControl[{0}]: name={1}; activeSelf={2}; activeInHierarchy={3}; anchors=({4},{5}); pos={6}; size={7}{8}{9}{10}{11}", obj));
					num++;
					continue;
				}
				break;
			}
		}

		private static bool WasGamepadPressed(Func<Gamepad, ButtonControl> accessor)
		{
			Gamepad current = Gamepad.current;
			if (current != null)
			{
				return accessor(current).wasPressedThisFrame;
			}
			return false;
		}
	}
	internal sealed class SuitSyncManager : MonoBehaviour
	{
		private sealed class CachedDesignPayload
		{
			public ulong OwnerClientId { get; }

			public int OwnerPlayerSlot { get; }

			public int SuitId { get; }

			public int Width { get; }

			public int Height { get; }

			public string DesignName { get; }

			public byte[] Bytes { get; }

			public CachedDesignPayload(ulong ownerClientId, int ownerPlayerSlot, int suitId, int width, int height, string designName, byte[] bytes)
			{
				OwnerClientId = ownerClientId;
				OwnerPlayerSlot = ownerPlayerSlot;
				SuitId = suitId;
				Width = width;
				Height = height;
				DesignName = designName;
				Bytes = bytes;
			}
		}

		private sealed class IncomingPayload
		{
			private readonly byte[][] _chunks;

			private int _received;

			public int SuitId { get; }

			public ulong OwnerClientId { get; }

			public int OwnerPlayerSlot { get; }

			public int Width { get; }

			public int Height { get; }

			public string DesignName { get; }

			public string Hash { get; }

			public int TotalBytes { get; }

			public bool IsComplete => _received == _chunks.Length;

			public IncomingPayload(ulong ownerClientId, int ownerPlayerSlot, int suitId, int width, int height, string designName, string hash, int totalBytes, int chunkCount)
			{
				OwnerClientId = ownerClientId;
				OwnerPlayerSlot = ownerPlayerSlot;
				SuitId = suitId;
				Width = width;
				Height = height;
				DesignName = designName;
				Hash = hash;
				TotalBytes = totalBytes;
				_chunks = new byte[Mathf.Max(1, chunkCount)][];
			}

			public void SetChunk(int index, byte[] bytes)
			{
				if (index >= 0 && index < _chunks.Length && bytes != null && _chunks[index] == null)
				{
					_chunks[index] = bytes;
					_received++;
				}
			}

			public byte[] Combine()
			{
				byte[] array = new byte[TotalBytes];
				int num = 0;
				byte[][] chunks = _chunks;
				foreach (byte[] array2 in chunks)
				{
					if (array2 != null)
					{
						Buffer.BlockCopy(array2, 0, array, num, array2.Length);
						num += array2.Length;
					}
				}
				return array;
			}
		}

		private const string MessageName = "DrawableSuits.Design";

		private const int MessageKindChunk = 1;

		private const int MessageKindRequestAll = 2;

		private const int MessageKindChunkV2 = 3;

		private const int MessageKindChunkV3 = 4;

		private const int LegacyDefaultMaxSyncBytes = 1048576;

		private const int RaisedDefaultMaxSyncBytes = 4194304;

		private readonly Dictionary<string, IncomingPayload> _incoming = new Dictionary<string, IncomingPayload>();

		private readonly Dictionary<string, CachedDesignPayload> _activePayloads = new Dictionary<string, CachedDesignPayload>(StringComparer.Ordinal);

		private bool _registered;

		private NetworkManager _registeredManager;

		private float _nextRegisterAttempt;

		private bool _loggedLegacyMaxSyncBytes;

		private void Update()
		{
			if (!(Time.unscaledTime < _nextRegisterAttempt))
			{
				_nextRegisterAttempt = Time.unscaledTime + 1f;
				EnsureRegistered();
			}
		}

		public void BroadcastDesign(SuitTextureState state)
		{
			if (!DrawableSuitsPlugin.ModConfig.EnableNetworkSync.Value || (Object)(object)state?.EditableTexture == (Object)null)
			{
				DrawableSuitsDiagnostics.Info($"SyncBroadcastSkipped: reason=disabled-or-missing-texture; stateNull={state == null}; hasTexture={(Object)(object)state?.EditableTexture != (Object)null}; networkSync={DrawableSuitsPlugin.ModConfig.EnableNetworkSync.Value}");
				return;
			}
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || singleton.CustomMessagingManager == null || !singleton.IsClient)
			{
				DrawableSuitsDiagnostics.Info(string.Format("SyncBroadcastSkipped: reason=network-not-ready; managerNull={0}; hasMessaging={1}; isClient={2}", (Object)(object)singleton == (Object)null, ((singleton != null) ? singleton.CustomMessagingManager : null) != null, ((singleton != null) ? singleton.IsClient.ToString() : null) ?? "null"));
				return;
			}
			state = DrawableSuitsPlugin.Registry?.NormalizeLocalStateOwner(state, "BroadcastDesign") ?? state;
			byte[] array = ImageConversion.EncodeToPNG(state.EditableTexture);
			if (array == null || array.Length == 0)
			{
				DrawableSuitsDiagnostics.Info($"SyncBroadcastSkipped: reason=empty-png; ownerClientId={state.OwnerClientId}; suitId={state.SuitId}; designName={state.ActiveDesignName}");
				return;
			}
			int num = EffectiveMaxSyncBytes();
			if (array.Length > num)
			{
				string text = $"Not syncing {state.SuitName}: PNG payload is {array.Length} bytes, over MaxSyncBytes {num}.";
				DrawableSuitsPlugin.ModLogger.LogWarning((object)text);
				DrawableSuitsDiagnostics.Warn($"SyncBroadcastSkipped: reason=payload-too-large; ownerClientId={state.OwnerClientId}; localClientId={singleton.LocalClientId}; suitId={state.SuitId}; designName={state.ActiveDesignName}; bytes={array.Length}; maxSyncBytes={num}");
				DrawableSuitsPlugin.Editor?.ShowExternalStatus($"Suit sync skipped: texture is {array.Length:n0} bytes, limit {num:n0}.", warn: true);
				return;
			}
			List<ulong> list = (singleton.IsServer ? OtherClientIds(singleton) : new List<ulong> { 0uL });
			ulong num2 = ((!state.IsPlayerSpecific) ? singleton.LocalClientId : (state.IsLocalPlayerState ? SuitTextureRegistry.ResolveLocalClientId() : state.OwnerClientId));
			int num3 = (state.IsPlayerSpecific ? ResolveStatePlayerSlot(state, num2) : (-1));
			DrawableSuitsDiagnostics.Info($"SyncOwnerResolved: context=BroadcastDesign; ownerClientId={num2}; ownerPlayerSlot={num3}; localClientId={singleton.LocalClientId}; localPlayerSlot={SuitTextureRegistry.ResolveLocalPlayerSlot()}; suitId={state.SuitId}; identities=[{DescribePlayerIdentities()}]");
			DrawableSuitsDiagnostics.Info(string.Format("SyncBroadcastQueued: ownerClientId={0}; ownerPlayerSlot={1}; localClientId={2}; suitId={3}; designName={4}; bytes={5}; recipients=[{6}]; isServer={7}; chunkBytes={8}", num2, num3, singleton.LocalClientId, state.SuitId, state.ActiveDesignName, array.Length, string.Join(",", list), singleton.IsServer, DrawableSuitsPlugin.ModConfig.SyncChunkBytes.Value));
			if (singleton.IsServer)
			{
				CacheActivePayload(num2, num3, state.SuitId, state.ActiveDesignName, ((Texture)state.EditableTexture).width, ((Texture)state.EditableTexture).height, array, "host-broadcast");
			}
			SendTextureChunks(singleton, list, num2, num3, state.SuitId, state.ActiveDesignName, ((Texture)state.EditableTexture).width, ((Texture)state.EditableTexture).height, array);
		}

		public unsafe void RequestActiveDesigns()
		{
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			if (!DrawableSuitsPlugin.ModConfig.EnableNetworkSync.Value)
			{
				return;
			}
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || singleton.CustomMessagingManager == null || !singleton.IsClient || singleton.IsServer)
			{
				DrawableSuitsDiagnostics.Info(string.Format("SyncRequestSkipped: reason=not-client-requester; managerNull={0}; hasMessaging={1}; isClient={2}; isServer={3}", (Object)(object)singleton == (Object)null, ((singleton != null) ? singleton.CustomMessagingManager : null) != null, ((singleton != null) ? singleton.IsClient.ToString() : null) ?? "null", ((singleton != null) ? singleton.IsServer.ToString() : null) ?? "null"));
				return;
			}
			EnsureRegistered();
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(16, (Allocator)2, 16);
			try
			{
				int num = 2;
				((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num, default(ForPrimitives));
				singleton.CustomMessagingManager.SendNamedMessage("DrawableSuits.Design", 0uL, val, (NetworkDelivery)2);
				DrawableSuitsDiagnostics.Info($"SyncRequestSent: requesterClientId={singleton.LocalClientId}; serverClientId={0uL}");
			}
			finally
			{
				((IDisposable)(*(FastBufferWriter*)(&val))/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private void EnsureRegistered()
		{
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Expected O, but got Unknown
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || singleton.CustomMessagingManager == null)
			{
				if (_incoming.Count > 0 || _activePayloads.Count > 0)
				{
					DrawableSuitsDiagnostics.Info($"SyncCacheCleared: reason=network-manager-unavailable; incoming={_incoming.Count}; cachedPayloads={_activePayloads.Count}");
					_incoming.Clear();
					_activePayloads.Clear();
				}
				_registered = false;
				_registeredManager = null;
			}
			else if (!_registered || singleton != _registeredManager)
			{
				NetworkManager registeredManager = _registeredManager;
				if (((registeredManager != null) ? registeredManager.CustomMessagingManager : null) != null)
				{
					_registeredManager.CustomMessagingManager.UnregisterNamedMessageHandler("DrawableSuits.Design");
				}
				if (singleton != _registeredManager && (_incoming.Count > 0 || _activePayloads.Count > 0))
				{
					DrawableSuitsDiagnostics.Info($"SyncCacheCleared: reason=network-manager-changed; incoming={_incoming.Count}; cachedPayloads={_activePayloads.Count}");
					_incoming.Clear();
					_activePayloads.Clear();
				}
				singleton.CustomMessagingManager.RegisterNamedMessageHandler("DrawableSuits.Design", new HandleNamedMessageDelegate(HandleMessage));
				_registered = true;
				_registeredManager = singleton;
				DrawableSuitsDiagnostics.Info($"SyncRegistered: manager={DrawableSuitsPlugin.DescribeUnityObject((Object)(object)singleton)}; localClientId={singleton.LocalClientId}; isClient={singleton.IsClient}; isServer={singleton.IsServer}; connectedClients={singleton.ConnectedClientsIds?.Count ?? 0}");
				DrawableSuitsDiagnostics.Info($"SyncPlayerIdentitySnapshot: context=Register; localClientId={singleton.LocalClientId}; localPlayerSlot={SuitTextureRegistry.ResolveLocalPlayerSlot()}; identities=[{DescribePlayerIdentities()}]");
			}
		}

		private void HandleMessage(ulong senderClientId, FastBufferReader reader)
		{
			//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_0025: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				int num = default(int);
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
				switch (num)
				{
				case 2:
					HandleRequestAll(senderClientId);
					break;
				case 1:
					HandleChunk(senderClientId, reader, 1);
					break;
				case 3:
					HandleChunk(senderClientId, reader, 2);
					break;
				case 4:
					HandleChunk(senderClientId, reader, 3);
					break;
				}
			}
			catch (Exception ex)
			{
				DrawableSuitsPlugin.ModLogger.LogWarning((object)$"Failed to read sync message from {senderClientId}: {ex.Message}");
				DrawableSuitsDiagnostics.Warn($"SyncChunkReadFailed: senderClientId={senderClientId}; stage=HandleMessage; reason={ex.GetType().Name}: {ex.Message}");
			}
		}

		private void HandleRequestAll(ulong senderClientId)
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || !singleton.IsServer)
			{
				return;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			int num = 0;
			foreach (CachedDesignPayload value in _activePayloads.Values)
			{
				if (value != null && value.Bytes != null && value.Bytes.Length != 0)
				{
					if (!IsOwnerConnected(singleton, value.OwnerClientId))
					{
						DrawableSuitsDiagnostics.Info($"SyncRequestPayloadSkipped: requesterClientId={senderClientId}; ownerClientId={value.OwnerClientId}; ownerPlayerSlot={value.OwnerPlayerSlot}; suitId={value.SuitId}; reason=owner-not-connected");
					}
					else
					{
						hashSet.Add(ActivePayloadKey(value.OwnerClientId, value.OwnerPlayerSlot, value.SuitId));
						SendTextureChunks(singleton, new List<ulong> { senderClientId }, value.OwnerClientId, value.OwnerPlayerSlot, value.SuitId, value.DesignName, value.Width, value.Height, value.Bytes);
						num++;
					}
				}
			}
			foreach (SuitTextureState activePlayerState in DrawableSuitsPlugin.Registry.ActivePlayerStates)
			{
				if ((Object)(object)activePlayerState?.EditableTexture == (Object)null || string.IsNullOrWhiteSpace(activePlayerState.ActiveDesignName))
				{
					continue;
				}
				ulong num2 = (activePlayerState.IsLocalPlayerState ? SuitTextureRegistry.ResolveLocalClientId() : activePlayerState.OwnerClientId);
				int num3 = ResolveStatePlayerSlot(activePlayerState, num2);
				if (!IsOwnerConnected(singleton, num2))
				{
					DrawableSuitsDiagnostics.Info($"SyncRequestPayloadSkipped: requesterClientId={senderClientId}; ownerClientId={num2}; ownerPlayerSlot={num3}; suitId={activePlayerState.SuitId}; reason=owner-not-connected");
					continue;
				}
				string item = ActivePayloadKey(num2, num3, activePlayerState.SuitId);
				if (!hashSet.Contains(item))
				{
					byte[] array = ImageConversion.EncodeToPNG(activePlayerState.EditableTexture);
					if (array == null || array.Length == 0 || array.Length > EffectiveMaxSyncBytes())
					{
						DrawableSuitsDiagnostics.Warn($"SyncRequestPayloadSkipped: requesterClientId={senderClientId}; ownerClientId={num2}; ownerPlayerSlot={num3}; suitId={activePlayerState.SuitId}; reason=empty-or-too-large; bytes={((array != null) ? array.Length : 0)}; maxSyncBytes={EffectiveMaxSyncBytes()}");
					}
					else
					{
						CacheActivePayload(num2, num3, activePlayerState.SuitId, activePlayerState.ActiveDesignName, ((Texture)activePlayerState.EditableTexture).width, ((Texture)activePlayerState.EditableTexture).height, array, "request-fallback-registry");
						SendTextureChunks(singleton, new List<ulong> { senderClientId }, num2, num3, activePlayerState.SuitId, activePlayerState.ActiveDesignName, ((Texture)activePlayerState.EditableTexture).width, ((Texture)activePlayerState.EditableTexture).height, array);
						num++;
					}
				}
			}
			DrawableSuitsDiagnostics.Info($"SyncRequestHandled: requesterClientId={senderClientId}; cachedPayloads={_activePayloads.Count}; sentPayloads={num}");
		}

		private void HandleChunk(ulong senderClientId, FastBufferReader reader, int version)
		{
			//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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0409: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: Expected O, but got Unknown
			ulong num = senderClientId;
			int num2 = -1;
			int num3 = -1;
			int width = 0;
			int height = 0;
			int num4 = -1;
			int num5 = 0;
			int num6 = 0;
			string empty = string.Empty;
			string empty2 = string.Empty;
			int num7 = 0;
			string text = "owner";
			byte[] bytes;
			try
			{
				if (version >= 2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref num, default(ForPrimitives));
				}
				if (version >= 3)
				{
					text = "ownerPlayerSlot";
					((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num2, default(ForPrimitives));
				}
				else
				{
					num2 = SuitTextureRegistry.ResolvePlayerSlotForClient(num);
				}
				text = "metadata";
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num3, default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref width, default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref height, default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num4, default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num5, default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num6, default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe(ref empty, false);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref empty2, false);
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num7, default(ForPrimitives));
				int num8 = EffectiveMaxSyncBytes();
				string text2 = ValidateChunkMetadata(width, height, num4, num5, num6, num7, num8);
				if (!string.IsNullOrEmpty(text2))
				{
					DrawableSuitsDiagnostics.Warn($"SyncPayloadReceived: status=rejected; reason={text2}; senderClientId={senderClientId}; ownerClientId={num}; ownerPlayerSlot={num2}; suitId={num3}; chunkIndex={num4}; chunkCount={num5}; chunkLength={num7}; totalBytes={num6}; maxSyncBytes={num8}; version=v{version}");
					return;
				}
				text = "chunk-bytes";
				bytes = new byte[num7];
				((FastBufferReader)(ref reader)).ReadBytesSafe(ref bytes, num7, 0);
			}
			catch (Exception ex)
			{
				DrawableSuitsDiagnostics.Warn($"SyncChunkReadFailed: senderClientId={senderClientId}; ownerClientId={num}; ownerPlayerSlot={num2}; suitId={num3}; chunkIndex={num4}; chunkCount={num5}; chunkLength={num7}; totalBytes={num6}; version=v{version}; stage={text}; reason={ex.GetType().Name}: {ex.Message}");
				return;
			}
			string key = $"{senderClientId}:{num}:{num2}:{num3}:{empty2}";
			if (!_incoming.TryGetValue(key, out var value))
			{
				value = new IncomingPayload(num, num2, num3, width, height, empty, empty2, num6, num5);
				_incoming[key] = value;
			}
			value.SetChunk(num4, bytes);
			if (!value.IsComplete)
			{
				return;
			}
			_incoming.Remove(key);
			byte[] array = value.Combine();
			DrawableSuitsDiagnostics.Info($"SyncPayloadReceived: status=complete; ownerClientId={num}; ownerPlayerSlot={num2}; senderClientId={senderClientId}; suitId={num3}; designName={empty}; bytes={array.Length}; chunks={num5}; version=v{version}");
			if (!string.Equals(empty2, Hash(array), StringComparison.OrdinalIgnoreCase))
			{
				DrawableSuitsPlugin.ModLogger.LogWarning((object)$"Rejected synced suit {num3} for client {num}: hash mismatch.");
				DrawableSuitsDiagnostics.Warn($"SyncPayloadReceived: status=rejected; reason=hash-mismatch; ownerClientId={num}; ownerPlayerSlot={num2}; senderClientId={senderClientId}; suitId={num3}; bytes={array.Length}");
				return;
			}
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
			if (!ImageConversion.LoadImage(val, array, false))
			{
				Object.Destroy((Object)(object)val);
				return;
			}
			DrawableSuitsDiagnostics.Info($"SyncPayloadMatchedPlayer: ownerClientId={num}; ownerPlayerSlot={num2}; suitId={num3}; target={FindPlayerIdentity(num, num2)}");
			DrawableSuitsPlugin.Registry.ApplyReceivedTexture(num, num2, num3, empty, val);
			Object.Destroy((Object)(object)val);
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton != (Object)null && singleton.IsServer)
			{
				CacheActivePayload(num, num2, num3, empty, width, height, array, "server-received");
			}
			if ((Object)(object)singleton != (Object)null && singleton.IsServer && senderClientId != singleton.LocalClientId)
			{
				List<ulong> recipients = (from id in OtherClientIds(singleton)
					where id != senderClientId
					select id).ToList();
				SendTextureChunks(singleton, recipients, num, num2, num3, empty, width, height, array);
			}
		}

		private static string ValidateChunkMetadata(int width, int height, int chunkIndex, int chunkCount, int totalBytes, int chunkLength, int maxSyncBytes)
		{
			if (width <= 0 || height <= 0)
			{
				return "invalid-texture-size";
			}
			if (chunkCount <= 0 || chunkIndex < 0 || chunkIndex >= chunkCount)
			{
				return "invalid-chunk-index";
			}
			if (chunkLength <= 0 || totalBytes <= 0 || totalBytes > maxSyncBytes)
			{
				return "invalid-size";
			}
			if (chunkLength > totalBytes || chunkLength > maxSyncBytes)
			{
				return "invalid-chunk-length";
			}
			return string.Empty;
		}

		private unsafe static void SendTextureChunks(NetworkManager manager, IReadOnlyList<ulong> recipients, ulong ownerClientId, int ownerPlayerSlot, int suitId, string designName, int width, int height, byte[] bytes)
		{
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: 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_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			if (((manager != null) ? manager.CustomMessagingManager : null) == null || recipients == null || recipients.Count == 0)
			{
				DrawableSuitsDiagnostics.Info(string.Format("SyncChunkSent: status=skipped; reason=no-recipients-or-messaging; ownerClientId={0}; ownerPlayerSlot={1}; localClientId={2}; suitId={3}; recipients={4}; bytes={5}", ownerClientId, ownerPlayerSlot, ((manager != null) ? manager.LocalClientId.ToString() : null) ?? "null", suitId, recipients?.Count ?? 0, (bytes != null) ? bytes.Length : 0));
				return;
			}
			int num = Mathf.Clamp(DrawableSuitsPlugin.ModConfig.SyncChunkBytes.Value, 4096, 60000);
			int num2 = Mathf.CeilToInt((float)bytes.Length / (float)num);
			string text = Hash(bytes);
			if (designName == null)
			{
				designName = string.Empty;
			}
			FastBufferWriter val = default(FastBufferWriter);
			for (int i = 0; i < num2; i++)
			{
				int num3 = i * num;
				int num4 = Math.Min(num, bytes.Length - num3);
				byte[] array = new byte[num4];
				Buffer.BlockCopy(bytes, num3, array, 0, num4);
				int num5 = num4 + 1024 + Encoding.UTF8.GetByteCount(designName) + Encoding.UTF8.GetByteCount(text);
				((FastBufferWriter)(ref val))..ctor(num5, (Allocator)2, num5);
				try
				{
					int num6 = 4;
					((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num6, default(ForPrimitives));
					((FastBufferWriter)(ref val)).WriteValueSafe<ulong>(ref ownerClientId, default(ForPrimitives));
					((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref ownerPlayerSlot, default(ForPrimitives));
					((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref suitId, default(ForPrimitives));
					((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref width, default(ForPrimitives));
					((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref height, default(ForPrimitives));
					((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref i, default(ForPrimitives));
					((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num2, default(ForPrimitives));
					num6 = bytes.Length;
					((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num6, default(ForPrimitives));
					((FastBufferWriter)(ref val)).WriteValueSafe(designName, false);
					((FastBufferWriter)(ref val)).WriteValueSafe(text, false);
					((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num4, default(ForPrimitives));
					((FastBufferWriter)(ref val)).WriteBytesSafe(array, num4, 0);
					foreach (ulong recipient in recipients)
					{
						manager.CustomMessagingManager.SendNamedMessage("DrawableSuits.Design", recipient, val, (NetworkDelivery)4);
					}
				}
				finally
				{
					((IDisposable)(*(FastBufferWriter*)(&val))/*cast due to .constrained prefix*/).Dispose();
				}
			}
			DrawableSuitsDiagnostics.Info(string.Format("SyncChunkSent: status=sent; ownerClientId={0}; ownerPlayerSlot={1}; localClientId={2}; suitId={3}; designName={4}; bytes={5}; chunkSize={6}; chunkCount={7}; recipients=[{8}]", ownerClientId, ownerPlayerSlot, manager.LocalClientId, suitId, designName, bytes.Length, num, num2, string.Join(",", recipients)));
		}

		private static List<ulong> OtherClientIds(NetworkManager manager)
		{
			List<ulong> list = new List<ulong>();
			if (((manager != null) ? manager.ConnectedClientsIds : null) == null)
			{
				return list;
			}
			foreach (ulong connectedClientsId in manager.ConnectedClientsIds)
			{
				if (connectedClientsId != manager.LocalClientId)
				{
					list.Add(connectedClientsId);
				}
			}
			return list;
		}

		private static bool IsOwnerConnected(NetworkManager manager, ulong ownerClientId)
		{
			if (((manager != null) ? manager.ConnectedClientsIds : null) == null)
			{
				return true;
			}
			return manager.ConnectedClientsIds.Contains(ownerClientId);
		}

		private static string Hash(byte[] bytes)
		{
			using SHA256 sHA = SHA256.Create();
			byte[] array = sHA.ComputeHash(bytes);
			StringBuilder stringBuilder = new StringBuilder(array.Length * 2);
			byte[] array2 = array;
			foreach (byte b in array2)
			{
				stringBuilder.Append(b.ToString("x2"));
			}
			return stringBuilder.ToString();
		}

		private int EffectiveMaxSyncBytes()
		{
			int num = Mathf.Max(4096, DrawableSuitsPlugin.ModConfig.MaxSyncBytes.Value);
			if (num <= 1048576)
			{
				if (!_loggedLegacyMaxSyncBytes)
				{
					_loggedLegacyMaxSyncBytes = true;
					DrawableSuitsDiagnostics.Info($"MaxSyncBytes raised for legacy/default config. configured={num}; effective={4194304}");
				}
				return 4194304;
			}
			return num;
		}

		private void CacheActivePayload(ulong ownerClientId, int ownerPlayerSlot, int suitId, string designName, int width, int height, byte[] bytes, string reason)
		{
			if (bytes != null && bytes.Length != 0)
			{
				int num = NormalizePlayerSlot(ownerPlayerSlot);
				string key = ActivePayloadKey(ownerClientId, num, suitId);
				_activePayloads[key] = new CachedDesignPayload(ownerClientId, num, suitId, width, height, designName ?? string.Empty, bytes);
				DrawableSuitsDiagnostics.Info($"SyncPayloadCached: reason={reason}; ownerClientId={ownerClientId}; ownerPlayerSlot={num}; suitId={suitId}; designName={designName}; texture={width}x{height}; bytes={bytes.Length}; cachedPayloads={_activePayloads.Count}");
			}
		}

		private static string ActivePayloadKey(ulong ownerClientId, int ownerPlayerSlot, int suitId)
		{
			if (ownerPlayerSlot < 0)
			{
				return $"client:{ownerClientId}:{suitId}";
			}
			return $"slot:{ownerPlayerSlot}:{suitId}";
		}

		private static int ResolveStatePlayerSlot(SuitTextureState state, ulong ownerClientId)
		{
			if (state != null && state.OwnerPlayerSlot >= 0)
			{
				return state.OwnerPlayerSlot;
			}
			int num = SuitTextureRegistry.ResolvePlayerSlotForClient(ownerClientId);
			if (num >= 0)
			{
				return num;
			}
			if (state == null || !state.IsLocalPlayerState)
			{
				return -1;
			}
			return SuitTextureRegistry.ResolveLocalPlayerSlot();
		}

		private static int NormalizePlayerSlot(int playerSlot)
		{
			if (playerSlot < 0 || playerSlot >= 64)
			{
				return -1;
			}
			return playerSlot;
		}

		private static string DescribePlayerIdentities()
		{
			PlayerControllerB[] array = StartOfRound.Instance?.allPlayerScripts;
			if (array == null || array.Length == 0)
			{
				return "players=none";
			}
			List<string> list = new List<string>();
			for (int i = 0; i < array.Length; i++)
			{
				if (!((Object)(object)array[i] == (Object)null))
				{
					list.Add(SuitTextureRegistry.DescribePlayerIdentity(array[i]));
				}
			}
			if (list.Count <= 0)
			{
				return "players=none";
			}
			return string.Join(" | ", list);
		}

		private static string FindPlayerIdentity(ulong ownerClientId, int ownerPlayerSlot)
		{
			PlayerControllerB[] array = StartOfRound.Instance?.allPlayerScripts;
			if (array == null || array.Length == 0)
			{
				DrawableSuitsDiagnostics.Warn($"SyncPayloadNoPlayerMatch: ownerClientId={ownerClientId}; ownerPlayerSlot={ownerPlayerSlot}; reason=players-not-ready");
				return "players-not-ready";
			}
			if (ownerPlayerSlot >= 0 && ownerPlayerSlot < array.Length && (Object)(object)array[ownerPlayerSlot] != (Object)null)
			{
				return SuitTextureRegistry.DescribePlayerIdentity(array[ownerPlayerSlot]);
			}
			PlayerControllerB[] array2 = array;
			foreach (PlayerControllerB val in array2)
			{
				if ((Object)(object)val != (Object)null && SuitTextureRegistry.GetPlayerClientId(val) == ownerClientId)
				{
					return SuitTextureRegistry.DescribePlayerIdentity(val);
				}
			}
			DrawableSuitsDiagnostics.Warn($"SyncPayloadNoPlayerMatch: ownerClientId={ownerClientId}; ownerPlayerSlot={ownerPlayerSlot}; identities=[{DescribePlayerIdentities()}]");
			return "no-match";
		}
	}
	internal sealed class SuitTextureRegistry : MonoBehaviour
	{
		private sealed class DeadBodyReapplyRequest
		{
			public DeadBodyInfo Body;

			public int Attempts;

			public float NextTime;

			public string Context;
		}

		public const int UnknownPlayerSlot = -1;

		private const int ReapplyRetryAttempts = 8;

		private const float ReapplyRetryIntervalSeconds = 0.25f;

		private readonly Dictionary<int, SuitTextureState> _states = new Dictionary<int, SuitTextureState>();

		private readonly Dictionary<string, SuitTextureState> _playerStates = new Dictionary<string, SuitTextureState>(StringComparer.Ordinal);

		private readonly Dictionary<Renderer, Material[]> _localRendererOriginalMaterials = new Dictionary<Renderer, Material[]>();

		private int _pendingReapplyAllAttempts;

		private float _nextPendingReapplyAllTime;

		private string _pendingReapplyAllContext = string.Empty;

		private readonly List<DeadBodyReapplyRequest> _pendingDeadBodyReapplications = new List<DeadBodyReapplyRequest>();

		private readonly Dictionary<int, int> _lastKnownSuitIdByPlayerSlot = new Dictionary<int, int>();

		private readonly Dictionary<ulong, int> _lastKnownSuitIdByClientId = new Dictionary<ulong, int>();

		public IReadOnlyDictionary<int, SuitTextureState> States => _states;

		public IEnumerable<SuitTextureState> ActivePlayerStates => _playerStates.Values;

		private void Update()
		{
			ProcessPendingReapplyAll();
			ProcessPendingDeadBodyReapplications();
		}

		private void ProcessPendingReapplyAll()
		{
			if (_pendingReapplyAllAttempts > 0 && !(Time.unscaledTime < _nextPendingReapplyAllTime))
			{
				_pendingReapplyAllAttempts--;
				_nextPendingReapplyAllTime = Time.unscaledTime + 0.25f;
				if (!CanReapplyAll(out var reason))
				{
					DrawableSuitsDiagnostics.Info($"SyncReapplySkipped: context={_pendingReapplyAllContext}; reason={reason}; attemptsRemaining={_pendingReapplyAllAttempts}");
					return;
				}
				ReapplyAll();
				DrawableSuitsDiagnostics.Info($"SyncReapplyApplied: context={_pendingReapplyAllContext}; attemptsRemaining={_pendingReapplyAllAttempts}; playerStates={_playerStates.Count}; sharedStates={_states.Count}");
			}
		}

		private void ProcessPendingDeadBodyReapplications()
		{
			if (_pendingDeadBodyReapplications.Count == 0)
			{
				return;
			}
			for (int num = _pendingDeadBodyReapplications.Count - 1; num >= 0; num--)
			{
				DeadBodyReapplyRequest deadBodyReapplyRequest = _pendingDeadBodyReapplications[num];
				if (deadBodyReapplyRequest == null || (Object)(object)deadBodyReapplyRequest.Body == (Object)null)
				{
					_pendingDeadBodyReapplications.RemoveAt(num);
				}
				else if (!(Time.unscaledTime < deadBodyReapplyRequest.NextTime))
				{
					deadBodyReapplyRequest.Attempts--;
					ApplyToDeadBody(deadBodyReapplyRequest.Body, "retry:" + deadBodyReapplyRequest.Context);
					if (deadBodyReapplyRequest.Attempts <= 0)
					{
						_pendingDeadBodyReapplications.RemoveAt(num);
					}
					else
					{
						deadBodyReapplyRequest.NextTime = Time.unscaledTime + 0.25f;
					}
				}
			}
		}

		public SuitTextureState GetOrCreateState(int suitId)
		{
			if ((Object)(object)StartOfRound.Instance?.localPlayerController != (Object)null)
			{
				return GetOrCreateLocalState(suitId);
			}
			return GetOrCreateSharedState(suitId);
		}

		private SuitTextureState GetOrCreateLocalState(int suitId)
		{
			ulong num = ResolveLocalClientId();
			int num2 = ResolveLocalPlayerSlot();
			string key = PlayerStateKey(num, num2, suitId);
			if (_playerStates.TryGetValue(key, out var value))
			{
				value.IsLocalPlayerState = true;
				return value;
			}
			SuitTextureState suitTextureState = TryMigrateLocalState(suitId, num, num2, "GetOrCreateLocalState");
			if (suitTextureState != null)
			{
				return suitTextureState;
			}
			value = CreateState(suitId, num, num2, playerSpecific: true, $"local client {num} slot {num2}", localPlayerState: true);
			if (value != null)
			{
				_playerStates[key] = value;
			}
			return value;
		}

		private SuitTextureState GetOrCreateSharedState(int suitId)
		{
			if (_states.TryGetValue(suitId, out var value))
			{
				return value;
			}
			value = CreateState(suitId, 0uL, -1, playerSpecific: false, "shared");
			if (value != null)
			{
				_states[suitId] = value;
			}
			return value;
		}

		public SuitTextureState GetOrCreateStateForPlayer(PlayerControllerB player, int suitId)
		{
			if ((Object)(object)player == (Object)null)
			{
				return GetOrCreateSharedState(suitId);
			}
			PlayerControllerB val = StartOfRound.Instance?.localPlayerController;
			if ((Object)(object)val != (Object)null && player == val)
			{
				return GetOrCreateLocalState(suitId);
			}
			return GetOrCreateStateForPlayerIdentity(GetPlayerClientId(player), GetPlayerSlot(player), suitId);
		}

		public SuitTextureState GetOrCreateStateForClient(ulong ownerClientId, int suitId)
		{
			return GetOrCreateStateForPlayerIdentity(ownerClientId, ResolvePlayerSlotForClient(ownerClientId), suitId);
		}

		public SuitTextureState GetOrCreateStateForPlayerIdentity(ulong ownerClientId, int ownerPlayerSlot, int suitId)
		{
			int num = NormalizePlayerSlot(ownerPlayerSlot);
			string key = PlayerStateKey(ownerClientId, num, suitId);
			if (_playerStates.TryGetValue(key, out var value))
			{
				if (IsOwnerLocal(ownerClientId))
				{
					value.IsLocalPlayerState = true;
				}
				value.OwnerPlayerSlot = num;
				return value;
			}
			value = CreateState(suitId, ownerClientId, num, playerSpecific: true, $"client {ownerClientId} slot {num}", IsOwnerLocal(ownerClientId));
			if (value != null)
			{
				_playerStates[key] = value;
			}
			return value;
		}

		private static string PlayerStateKey(ulong ownerClientId, int ownerPlayerSlot, int suitId)
		{
			if (ownerPlayerSlot < 0)
			{
				return $"client:{ownerClientId}:{suitId}";
			}
			return $"slot:{ownerPlayerSlot}:{suitId}";
		}

		private SuitTextureState CreateState(int suitId, ulong ownerClientId, int ownerPlayerSlot, bool playerSpecific, string context, bool localPlayerState = false)
		{
			//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_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			UnlockableItem unlockableItem = GetUnlockableItem(suitId);
			if (unlockableItem == null || (Object)(object)unlockableItem.suitMaterial == (Object)null)
			{
				return null;
			}
			int value = DrawableSuitsPlugin.ModConfig.MaxTextureSize.Value;
			Texture mainTexture = unlockableItem.suitMaterial.mainTexture;
			Texture2D baseTexture = TextureTools.CreateEditableCopy(mainTexture, value);
			Texture2D val = TextureTools.CreateEditableCopy(mainTexture, value);
			Material val2 = new Material(unlockableItem.suitMaterial)
			{
				name = (playerSpecific ? $"{((Object)unlockableItem.suitMaterial).name} (DrawableSuits client {ownerClientId})" : (((Object)unlockableItem.suitMaterial).name + " (DrawableSuits shared)")),
				mainTexture = (Texture)(object)val
			};
			SuitTextureState suitTextureState = new SuitTextureState
			{
				SuitId = suitId,
				OwnerClientId = ownerClientId,
				OwnerPlayerSlot = NormalizePlayerSlot(ownerPlayerSlot),
				IsPlayerSpecific = playerSpecific,
				IsLocalPlayerState = localPlayerState,
				SuitName = (string.IsNullOrWhiteSpace(unlockableItem.unlockableName) ? $"Suit {suitId}" : unlockableItem.unlockableName),
				OriginalMaterial = unlockableItem.suitMaterial,
				OriginalTexture = mainTexture,
				RuntimeMaterial = val2,
				BaseTexture = baseTexture,
				EditableTexture = val,
				ActiveDesignName = string.Empty
			};
			DrawableSuitsDiagnostics.Info($"Created texture state. context={context}; suitId={suitId}; ownerClientId={ownerClientId}; ownerPlayerSlot={suitTextureState.OwnerPlayerSlot}; playerSpecific={playerSpecific}; localPlayerState={localPlayerState}; material={((Object)val2).name}; texture={((Object)val).name} {((Texture)val).width}x{((Texture)val).height}");
			return suitTextureState;
		}

		public Texture2D GetEditableTexture(int suitId)
		{
			return GetOrCreateState(suitId)?.EditableTexture;
		}

		public Texture2D GetEditableTextureForPlayer(PlayerControllerB player, int suitId)
		{
			return GetOrCreateStateForPlayer(player, suitId)?.EditableTexture;
		}

		public Material GetRuntimeMaterial(int suitId)
		{
			return GetOrCreateState(suitId)?.RuntimeMaterial;
		}

		public Material GetRuntimeMaterialForPlayer(PlayerControllerB player, int suitId)
		{
			return GetOrCreateStateForPlayer(player, suitId)?.RuntimeMaterial;
		}

		public void ApplyEditedTexture(int suitId, string designName, bool broadcast)
		{
			SuitTextureState orCreateState = GetOrCreateState(suitId);
			if (orCreateState == null)
			{
				return;
			}
			orCreateState = NormalizeLocalStateOwner(orCreateState, "ApplyEditedTexture");
			if (orCreateState != null)
			{
				orCreateState.RuntimeMaterial.mainTexture = (Texture)(object)orCreateState.EditableTexture;
				orCreateState.ActiveDesignName = designName ?? string.Empty;
				ApplyStateToOwner(orCreateState);
				ReapplyDeadBodies($"ApplyEditedTexture suit={suitId}");
				if (broadcast)
				{
					DrawableSuitsPlugin.Sync.BroadcastDesign(orCreateState);
				}
			}
		}

		public void ApplyReceivedTexture(int suitId, string designName, Texture2D texture)
		{
			ApplyReceivedTexture(ResolveLocalClientId(), suitId, designName, texture);
		}

		public void ApplyReceivedTexture(ulong ownerClientId, int suitId, string designName, Texture2D texture)
		{
			ApplyReceivedTexture(ownerClientId, ResolvePlayerSlotForClient(ownerClientId), suitId, designName, texture);
		}

		public void ApplyReceivedTexture(ulong ownerClientId, int ownerPlayerSlot, int suitId, string designName, Texture2D texture)
		{
			int num = NormalizePlayerSlot(ownerPlayerSlot);
			SuitTextureState orCreateStateForPlayerIdentity = GetOrCreateStateForPlayerIdentity(ownerClientId, num, suitId);
			if (orCreateStateForPlayerIdentity != null && !((Object)(object)texture == (Object)null))
			{
				TextureTools.CopyInto(orCreateStateForPlayerIdentity.EditableTexture, texture);
				orCreateStateForPlayerIdentity.RuntimeMaterial.mainTexture = (Texture)(object)orCreateStateForPlayerIdentity.EditableTexture;
				orCreateStateForPlayerIdentity.ActiveDesignName = designName ?? "Received design";
				RecordSuitSnapshot(ownerClientId, num, suitId, "ApplyReceivedTexture", $"ownerClientId={ownerClientId}; ownerPlayerSlot={num}; suitId={suitId}");
				ApplyStateToOwner(orCreateStateForPlayerIdentity);
				ReapplyDeadBodies($"ApplyReceivedTexture owner={ownerClientId} suit={suitId}");
				ScheduleReapplyAll($"ApplyReceivedTexture owner={ownerClientId} suit={suitId}");
				DrawableSuitsDiagnostics.Info($"SyncPayloadApplied: ownerClientId={ownerClientId}; ownerPlayerSlot={num}; suitId={suitId}; designName={orCreateStateForPlayerIdentity.ActiveDesignName}; texture={((Texture)orCreateStateForPlayerIdentity.EditableTexture).width}x{((Texture)orCreateStateForPlayerIdentity.EditableTexture).height}; localPlayerState={orCreateStateForPlayerIdentity.IsLocalPlayerState}");
			}
		}

		public void ResetSuit(int suitId)
		{
			SuitTextureState orCreateState = GetOrCreateState(suitId);
			if (orCreateState != null)
			{
				TextureTools.CopyInto(orCreateState.EditableTexture, orCreateState.BaseTexture);
				orCreateState.ActiveDesignName = string.Empty;
				ApplyStateToOwner(orCreateState);
				ReapplyDeadBodies($"ResetSuit suit={suitId}");
			}
		}

		public void ReapplyAll()
		{
			StartOfRound instance = StartOfRound.Instance;
			if (instance?.allPlayerScripts != null)
			{
				PlayerControllerB[] allPlayerScripts = instance.allPlayerScripts;
				foreach (PlayerControllerB player in allPlayerScripts)
				{
					ApplyToPlayer(player);
				}
				ReapplyDeadBodies("ReapplyAll", scheduleRetries: false);
			}
		}

		public void ReapplyAllIfReady(string context)
		{
			if (!CanReapplyAll(out var reason))
			{
				DrawableSuitsDiagnostics.Info($"ReapplyAll skipped. context={context}; reason={reason}; knownStates={_states.Count}");
				return;
			}
			ReapplyAll();
			ScheduleReapplyAll(context);
		}

		public void ScheduleReapplyAll(string context)
		{
			_pendingReapplyAllAttempts = Mathf.Max(_pendingReapplyAllAttempts, 8);
			if (_nextPendingReapplyAllTime <= 0f || Time.unscaledTime + 0.05f < _nextPendingReapplyAllTime)
			{
				_nextPendingReapplyAllTime = Time.unscaledTime + 0.05f;
			}
			_pendingReapplyAllContext = context ?? string.Empty;
			DrawableSuitsDiagnostics.Info($"SyncReapplyScheduled: context={_pendingReapplyAllContext}; attempts={_pendingReapplyAllAttempts}; nextIn={Mathf.Max(0f, _nextPendingReapplyAllTime - Time.unscaledTime):0.###}; playerStates={_playerStates.Count}; sharedStates={_states.Count}");
		}

		private static bool CanReapplyAll(out string reason)
		{
			StartOfRound instance = StartOfRound.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				reason = "StartOfRound.Instance=null";
				return false;
			}
			List<UnlockableItem> list = instance.unlockablesList?.unlockables;
			if (list == null || list.Count == 0)
			{
				reason = "unlockables not ready";
				return false;
			}
			if (instance.allPlayerScripts == null || instance.allPlayerScripts.Length == 0)
			{
				reason = "players not ready";
				return false;
			}
			reason = "ready";
			return true;
		}

		public void RefreshKnownSuitMaterials()
		{
			DrawableSuitsDiagnostics.Info("RefreshKnownSuitMaterials skipped: DrawableSuits 0.4.4 keeps active edits player-specific and no longer mutates UnlockableItem.suitMaterial.");
		}

		public int GetLocalSuitId()
		{
			PlayerControllerB val = StartOfRound.Instance?.localPlayerController;
			if (!((Object)(object)val != (Object)null))
			{
				return -1;
			}
			return val.currentSuitID;
		}

		public List<int> GetSuitIds()
		{
			List<int> list = new List<int>();
			List<UnlockableItem> list2 = StartOfRound.Instance?.unlockablesList?.unlockables;
			if (list2 == null)
			{
				return list;
			}
			for (int i = 0; i < list2.Count; i++)
			{
				if ((Object)(object)list2[i]?.suitMaterial != (Object)null)
				{
					list.Add(i);
				}
			}
			return list;
		}

		public string GetSuitName(int suitId)
		{
			UnlockableItem unlockableItem = GetUnlockableItem(suitId);
			if (unlockableItem == null)
			{
				return $"Suit {suitId}";
			}
			if (!string.IsNullOrWhiteSpace(unlockableItem.unlockableName))
			{
				return unlockableItem.unlockableName;
			}
			return $"Suit {suitId}";
		}

		public bool SaveDesign(int suitId, string designName)
		{
			SuitTextureState orCreateState = GetOrCreateState(suitId);
			if (orCreateState == null)
			{
				return false;
			}
			string text = TextureTools.SanitizeFileName(designName);
			string text2 = text + ".png";
			string path = text + ".json";
			string path2 = Path.Combine(DrawableSuitsPaths.Textures, text2);
			string path3 = Path.Combine(DrawableSuitsPaths.Saves, path);
			File.WriteAllBytes(path2, ImageConversion.EncodeToPNG(orCreateState.EditableTexture));
			string text3 = DateTime.UtcNow.ToString("o");
			SuitDesignMetadata suitDesignMetadata = new SuitDesignMetadata
			{
				version = "0.5.77",
				name = text,
				baseSuitName = orCreateState.SuitName,
				sourceSuitId = suitId,
				textureFile = text2,
				width = ((Texture)orCreateState.EditableTexture).width,
				height = ((Texture)orCreateState.EditableTexture).height,
				createdUtc = text3,
				updatedUtc = text3
			};
			File.WriteAllText(path3, JsonUtility.ToJson((object)suitDesignMetadata, true));
			orCreateState.ActiveDesignName = text;
			ApplyEditedTexture(suitId, text, broadcast: true);
			return true;
		}

		public bool LoadDesign(int suitId, string metadataPath)
		{
			try
			{
				SuitDesignMetadata suitDesignMetadata = JsonUtility.FromJson<SuitDesignMetadata>(File.ReadAllText(metadataPath));
				if (suitDesignMetadata == null || string.IsNullOrWhiteSpace(suitDesignMetadata.textureFile))
				{
					return false;
				}
				string path = Path.Combine(DrawableSuitsPaths.Textures, suitDesignMetadata.textureFile);
				if (!File.Exists(path))
				{
					return false;
				}
				Texture2D val = TextureTools.LoadImageFile(path, DrawableSuitsPlugin.ModConfig.MaxTextureSize.Value);
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				ApplyReceivedTexture(suitId, suitDesignMetadata.name, val);
				Object.Destroy((Object)(object)val);
				return true;
			}
			catch (Exception ex)
			{
				DrawableSuitsPlugin.ModLogger.LogWarning((object)("Failed to load design '" + metadataPath + "': " + ex.Message));
				return false;
			}
		}

		public bool TryExportDesignCode(int suitId, string designName, out string code, out DrawableSuitDesignCode.CodeInfo info, out string failureReason)
		{
			SuitTextureState orCreateState = GetOrCreateState(suitId);
			if (orCreateState == null)
			{
				code = string.Empty;
				info = default(DrawableSuitDesignCode.CodeInfo);
				failureReason = "Selected suit is not editable.";
				return false;
			}
			return DrawableSuitDesignCode.TryExport(orCreateState, designName, out code, out info, out failureReason);
		}

		public bool ImportDecodedDesignCode(int suitId, DrawableSuitDesignCode.Payload payload, Texture2D texture, out string importedDesignName, out string failureReason)
		{
			importedDesignName = string.Empty;
			failureReason = string.Empty;
			SuitTextureState orCreateState = GetOrCreateState(suitId);
			if (orCreateState == null)
			{
				failureReason = "Selected suit is not editable.";
				return false;
			}
			if (payload == null)
			{
				failureReason = "Design code payload is missing.";
				return false;
			}
			if ((Object)(object)texture == (Object)null)
			{
				failureReason = "Design code texture is missing.";
				return false;
			}
			if (string.IsNullOrWhiteSpace(payload.designName))
			{
				failureReason = "Design code is missing a design name.";
				return false;
			}
			importedDesignName = TextureTools.SanitizeFileName(payload.designName);
			TextureTools.CopyInto(orCreateState.EditableTexture, texture);
			orCreateState.RuntimeMaterial.mainTexture = (Texture)(object)orCreateState.EditableTexture;
			orCreateState.ActiveDesignName = importedDesignName;
			ApplyStateToOwner(orCreateState);
			return true;
		}

		public void ApplyStateToWorld(SuitTextureState state)
		{
			state = NormalizeLocalStateOwner(state, "ApplyStateToWorld");
			ApplyStateToOwner(state);
		}

		public void ApplyStateToOwner(SuitTextureState state)
		{
			if (state == null)
			{
				return;
			}
			RecordStateSuitSnapshot(state, "ApplyStateToOwner");
			StartOfRound instance = StartOfRound.Instance;
			if (instance?.allPlayerScripts == null)
			{
				return;
			}
			PlayerControllerB[] allPlayerScripts = instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if ((Object)(object)val != (Object)null && val.currentSuitID == state.SuitId && (!state.IsPlayerSpecific || PlayerMatchesStateOwner(val, state)))
				{
					ApplyToPlayer(val, state);
				}
			}
		}

		public void ApplyToPlayer(PlayerControllerB player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			RecordPlayerSuitSnapshot(player, "ApplyToPlayer");
			string key = PlayerStateKey(GetPlayerClientId(player), GetPlayerSlot(player), player.currentSuitID);
			if (!_playerStates.TryGetValue(key, out var value))
			{
				string key2 = PlayerStateKey(GetPlayerClientId(player), -1, player.currentSuitID);
				if (!_playerStates.TryGetValue(key2, out value) && !_states.TryGetValue(player.currentSuitID, out value))
				{
					return;
				}
			}
			ApplyToPlayer(player, value);
		}

		public void RecordPlayerSuitSnapshot(PlayerControllerB player, string context)
		{
			if (!((Object)(object)player == (Object)null))
			{
				RecordSuitSnapshot(GetPlayerClientId(player), GetPlayerSlot(player), player.currentSuitID, context, DescribePlayerIdentity(player));
			}
		}

		private void RecordStateSuitSnapshot(SuitTextureState state, string context)
		{
			if (state != null)
			{
				RecordSuitSnapshot(state.OwnerClientId, state.OwnerPlayerSlot, state.SuitId, context, $"ownerClientId={state.OwnerClientId}; ownerPlayerSlot={state.OwnerPlayerSlot}; suitId={state.SuitId}; state={state.ActiveDesignName}");
			}
		}

		private void RecordSuitSnapshot(ulong ownerClientId, int ownerPlayerSlot, int suitId, string context, string identity)
		{
			if (suitId >= 0)
			{
				int num = NormalizePlayerSlot(ownerPlayerSlot);
				bool flag = false;
				if (num >= 0 && (!_lastKnownSuitIdByPlayerSlot.TryGetValue(num, out var value) || value != suitId))
				{
					_lastKnownSuitIdByPlayerSlot[num] = suitId;
					flag = true;
				}
				if (!_lastKnownSuitIdByClientId.TryGetValue(ownerClientId, out var value2) || value2 != suitId)
				{
					_lastKnownSuitIdByClientId[ownerClientId] = suitId;
					flag = true;
				}
				if (flag)
				{
					DrawableSuitsDiagnostics.Info($"DeadBodySuitIdSnapshot: context={context}; ownerClientId={ownerClientId}; ownerPlayerSlot={num}; suitId={suitId}; identity={identity}");
				}
			}
		}

		public void ApplyToDeadBody(DeadBodyInfo body, string context)
		{
			if (TryResolveDeadBodyState(body, context, out var player, out var playerSlot, out var suitId, out var state, out var resolveSummary))
			{
				state.RuntimeMaterial.mainTexture = (Texture)(object)state.EditableTexture;
				int candidateCount;
				string rendererSummary;
				int num = ApplyMaterialToDeadBodyRenderers(body, state.RuntimeMaterial, out candidateCount, out rendererSummary);
				if (num <= 0)
				{
					DrawableSuitsDiagnostics.Info($"DeadBodySuitApplySkipped: context={context}; reason=no-compatible-renderers; {DescribePlayerIdentity(player)}; playerObjectId={body.playerObjectId}; resolvedSlot={playerSlot}; suitId={suitId}; resolve={resolveSummary}; candidates={candidateCount}; material={((Object)state.RuntimeMaterial).name}; body={((Object)body).name}; renderers=[{rendererSummary}]");
				}
				else
				{
					DrawableSuitsDiagnostics.Info($"DeadBodySuitApplied: context={context}; {DescribePlayerIdentity(player)}; ownerClientId={state.OwnerClientId}; ownerPlayerSlot={state.OwnerPlayerSlot}; playerObjectId={body.playerObjectId}; resolvedSlot={playerSlot}; suitId={suitId}; resolve={resolveSummary}; renderers={num}; candidates={candidateCount}; material={((Object)state.RuntimeMaterial).name}; designName={state.ActiveDesignName}; body={((Object)body).name}; renderers=[{rendererSummary}]");
				}
			}
		}

		public bool TryGetDeadBodyRuntimeMaterial(DeadBodyInfo body, string context, out Material material, out string reason)
		{
			material = null;
			if (!TryResolveDeadBodyState(body, context, out var _, out var _, out var _, out var state, out reason))
			{
				return false;
			}
			material = state.RuntimeMaterial;
			material.mainTexture = (Texture)(object)state.EditableTexture;
			return (Object)(object)material != (Object)null;
		}

		public void ScheduleDeadBodyReapply(DeadBodyInfo body, string context)
		{
			if ((Object)(object)body == (Object)null)
			{
				DrawableSuitsDiagnostics.Info("DeadBodySuitReapplySkipped: context=" + context + "; reason=body-null");
				return;
			}
			DeadBodyReapplyRequest deadBodyReapplyRequest = null;
			for (int i = 0; i < _pendingDeadBodyReapplications.Count; i++)
			{
				if ((Object)(object)_pendingDeadBodyReapplications[i]?.Body == (Object)(object)body)
				{
					deadBodyReapplyRequest = _pendingDeadBodyReapplications[i];
					break;
				}
			}
			if (deadBodyReapplyRequest == null)
			{
				deadBodyReapplyRequest = new DeadBodyReapplyRequest
				{
					Body = body
				};
				_pendingDeadBodyReapplications.Add(deadBodyReapplyRequest);
			}
			deadBodyReapplyRequest.Attempts = Mathf.Max(deadBodyReapplyRequest.Attempts, 8);
			deadBodyReapplyRequest.NextTime = Time.unscaledTime + 0.05f;
			deadBodyReapplyRequest.Context = context ?? string.Empty;
			DrawableSuitsDiagnostics.Info($"DeadBodySuitReapplyScheduled: context={deadBodyReapplyRequest.Context}; attempts={deadBodyReapplyRequest.Attempts}; nextIn={Mathf.Max(0f, deadBodyReapplyRequest.NextTime - Time.unscaledTime):0.###}; playerObjectId={body.playerObjectId}; body={((Object)body).name}");
		}

		public void ReapplyDeadBodies(string context, bool scheduleRetries = true)
		{
			DeadBodyInfo[] array = Object.FindObjectsOfType<DeadBodyInfo>();
			int num = ((array != null) ? array.Length : 0);
			int num2 = 0;
			if (array != null)
			{
				foreach (DeadBodyInfo val in array)
				{
					if (!((Object)(object)val == (Object)null))
					{
						ApplyToDeadBody(val, context);
						if (scheduleRetries)
						{
							ScheduleDeadBodyReapply(val, context);
							num2++;
						}
					}
				}
			}
			if (num > 0)
			{
				DrawableSuitsDiagnostics.Info($"DeadBodySuitReapplyExisting: context={context}; found={num}; scheduled={num2}; scheduleRetries={scheduleRetries}");
			}
		}

		private SuitTextureState FindStateForPlayer(PlayerControllerB player, int suitId)
		{
			if ((Object)(object)player == (Object)null)
			{
				if (!_states.TryGetValue(suitId, out var value))
				{
					return null;
				}
				return value;
			}
			string key = PlayerStateKey(GetPlayerClientId(player), GetPlayerSlot(player), suitId);
			if (_playerStates.TryGetValue(key, out var value2))
			{
				return value2;
			}
			string key2 = PlayerStateKey(GetPlayerClientId(player), -1, suitId);
			if (_playerStates.TryGetValue(key2, out value2))
			{
				return value2;
			}
			if (_states.TryGetValue(suitId, out value2))
			{
				return value2;
			}
			return GetOrCreateStateForPlayer(player, suitId);
		}

		private bool TryResolveDeadBodyState(DeadBodyInfo body, string context, out PlayerControllerB player, out int playerSlot, out int suitId, out SuitTextureState state, out string resolveSummary)
		{
			player = null;
			playerSlot = -1;
			suitId = -1;
			state = null;
			resolveSummary = string.Empty;
			if ((Object)(object)body == (Object)null)
			{
				resolveSummary = "body-null";
				DrawableSuitsDiagnostics.Info("DeadBodySuitApplySkipped: context=" + context + "; reason=body-null");
				return false;
			}
			player = ResolveDeadBodyPlayer(body, out playerSlot, out var reason);
			if ((Object)(object)player == (Object)null)
			{
				resolveSummary = "playerResolve=" + reason;
				DrawableSuitsDiagnostics.Info($"DeadBodySuitApplySkipped: context={context}; reason=no-player; playerObjectId={body.playerObjectId}; resolvedSlot={playerSlot}; resolve={resolveSummary}; body={((Object)body).name}");
				return false;
			}
			suitId = ResolveDeadBodySuitId(player, playerSlot, out var source);
			resolveSummary = "playerResolve=" + reason + "; suitResolve=" + source;
			if (suitId < 0)
			{
				DrawableSuitsDiagnostics.Info($"DeadBodySuitApplySkipped: context={context}; reason=invalid-suit; {DescribePlayerIdentity(player)}; playerObjectId={body.playerObjectId}; resolvedSlot={playerSlot}; resolve={resolveSummary}; body={((Object)body).name}");
				return false;
			}
			state = FindStateForPlayer(player, suitId);
			if ((Object)(object)state?.RuntimeMaterial == (Object)null)
			{
				DrawableSuitsDiagnostics.Info($"DeadBodySuitApplySkipped: context={context}; reason=no-state; {DescribePlayerIdentity(player)}; playerObjectId={body.playerObjectId}; resolvedSlot={playerSlot}; suitId={suitId}; resolve={resolveSummary}; body={((Object)body).name}");
				return false;
			}
			return true;
		}

		private int ResolveDeadBodySuitId(PlayerControllerB player, int playerSlot, out string source)
		{
			int num = NormalizePlayerSlot(playerSlot);
			if (num >= 0 && _lastKnownSuitIdByPlayerSlot.TryGetValue(num, out var value) && value >= 0)
			{
				source = $"slot-snapshot:{num}";
				return value;
			}
			ulong playerClientId = GetPlayerClientId(player);
			if (_lastKnownSuitIdByClientId.TryGetValue(playerClientId, out value) && value >= 0)
			{
				source = $"client-snapshot:{playerClientId}";
				return value;
			}
			if ((Object)(object)player != (Object)null && player.currentSuitID >= 0)
			{
				source = "player.currentSuitID";
				return player.currentSuitID;
			}
			source = "none";
			return -1;
		}

		private static PlayerControllerB ResolveDeadBodyPlayer(DeadBodyInfo body, out int playerSlot, out string reason)
		{
			playerSlot = -1;
			if ((Object)(object)body == (Object)null)
			{
				reason = "body-null";
				return null;
			}
			if ((Object)(object)body.playerScript != (Object)null)
			{
				playerSlot = GetPlayerSlot(body.playerScript);
				reason = "playerScript";
				return body.playerScript;
			}
			PlayerControllerB[] array = StartOfRound.Instance?.allPlayerScripts;
			if (array != null && body.playerObjectId >= 0 && body.playerObjectId < array.Length && (Object)(object)array[body.playerObjectId] != (Object)null)
			{
				playerSlot = body.playerObjectId;
				reason = "playerObjectId";
				return array[body.playerObjectId];
			}
			RagdollGrabbableObject componentInParent = ((Component)body).GetComponentInParent<RagdollGrabbableObject>();
			if (array != null && (Object)(object)componentInParent != (Object)null && componentInParent.bodyID >= 0 && componentInParent.bodyID < array.Length && (Object)(object)array[componentInParent.bodyID] != (Object)null)
			{
				playerSlot = componentInParent.bodyID;
				reason = "ragdoll.bodyID";
				return array[componentInParent.bodyID];
			}
			reason = string.Format("no-match playerObjectId={0}; ragdollBodyId={1}", body.playerObjectId, ((Object)(object)componentInParent != (Object)null) ? componentInParent.bodyID.ToString() : "none");
			return null;
		}

		private static int ApplyMaterialToDeadBodyRenderers(DeadBodyInfo body, Material material, out int candidateCount, out string rendererSummary)
		{
			candidateCount = 0;
			rendererSummary = string.Empty;
			if ((Object)(object)body == (Object)null || (Object)(object)material == (Object)null)
			{
				return 0;
			}
			HashSet<Renderer> hashSet = new HashSet<Renderer>();
			Renderer[] componentsInChildren = ((Component)body).GetComponentsInChildren<Renderer>(true);
			if (componentsInChildren != null)
			{
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					AddDeadBodyRenderer(componentsInChildren[i], hashSet);
				}
			}
			AddDeadBodyRenderer((Renderer)(object)((GrabbableObject)(((Component)body).GetComponentInParent<RagdollGrabbableObject>()?)).mainObjectRenderer, hashSet);
			AddDeadBodyRenderer((Renderer)(object)((GrabbableObject)(((Component)body).GetComponent<RagdollGrabbableObject>()?)).mainObjectRenderer, hashSet);
			if ((Object)(object)body.grabBodyObject != (Object)null)
			{
				GrabbableObject grabBodyObject = body.grabBodyObject;
				AddDeadBodyRenderer((Renderer)(object)((grabBodyObject is RagdollGrabbableObject) ? grabBodyObject : null)?.mainObjectRenderer, hashSet);
				Renderer[] componentsInChildren2 = ((Component)body.grabBodyObject).GetComponentsInChildren<Renderer>(true);
				if (componentsInChildren2 != null)
				{
					for (int j = 0; j < componentsInChildren2.Length; j++)
					{
						AddDeadBodyRenderer(componentsInChildren2[j], hashSet);
					}
				}
			}
			if ((Object)(object)body.detachedHeadObject != (Object)null)
			{
				Renderer[] componentsInChildren3 = ((Component)body.detachedHeadObject).GetComponentsInChildren<Renderer>(true);
				if (componentsInChildren3 != null)
				{
					for (int k = 0; k < componentsInChildren3.Length; k++)
					{
						AddDeadBodyRenderer(componentsInChildren3[k], hashSet);
					}
				}
			}
			candidateCount = hashSet.Count;
			int num = 0;
			List<string> list = new List<string>();
			foreach (Renderer item in hashSet)
			{
				if (!((Object)(object)item == (Object)null))
				{
					string text = DescribeRendererMaterials(item);
					SetDeadBodyRendererMaterial(item, material);
					num++;
					if (list.Count < 8)
					{
						list.Add(((object)item).GetType().Name + ":" + GetTransformPath(((Component)item).transform) + " before=[" + text + "] after=[" + DescribeRendererMaterials(item) + "]");
					}
				}
			}
			rendererSummary = string.Join(", ", list);
			if (candidateCount > list.Count)
			{
				rendererSummary += $", +{candidateCount - list.Count} more";
			}
			return num;
		}

		private static void SetDeadBodyRendererMaterial(Renderer renderer, Material material)
		{
			if ((Object)(object)renderer == (Object)null || (Object)(object)material == (Object)null)
			{
				return;
			}
			Material[] sharedMaterials = renderer.sharedMaterials;
			if (sharedMaterials == null || sharedMaterials.Length == 0)
			{
				renderer.sharedMaterial = material;
			}
			else
			{
				for (int i = 0; i < sharedMaterials.Length; i++)
				{
					sharedMaterials[i] = material;
				}
				renderer.sharedMaterials = sharedMaterials;
			}
			try
			{
				Material[] materials = renderer.materials;
				if (materials != null && materials.Length != 0)
				{
					for (int j = 0; j < materials.Length; j++)
					{
						materials[j] = material;
					}
					renderer.materials = materials;
				}
			}
			catch (Exception ex)
			{
				DrawableSuitsDiagnostics.Warn("DeadBodySuitRendererMaterialInstanceSkipped: renderer=" + GetTransformPath(((Component)renderer).transform) + "; reason=" + ex.GetType().Name + ":" + ex.Message);
			}
		}

		private static string DescribeRendererMaterials(Renderer renderer)
		{
			if ((Object)(object)renderer == (Object)null)
			{
				return "renderer-null";
			}
			Material[] sharedMaterials = renderer.sharedMaterials;
			if (sharedMaterials == null || sharedMaterials.Length == 0)
			{
				if (!((Object)(object)renderer.sharedMaterial != (Object)null))
				{
					return "none";
				}
				return ((Object)renderer.sharedMaterial).name;
			}
			List<string> list = new List<string>();
			for (int i = 0; i < sharedMaterials.Length && i < 4; i++)
			{
				list.Add(((Object)(object)sharedMaterials[i] != (Object)null) ? ((Object)sharedMaterials[i]).name : "null");
			}
			if (sharedMaterials.Length > list.Count)
			{
				list.Add($"+{sharedMaterials.Length - list.Count} more");
			}
			return string.Join("|", list);
		}

		private static void AddDeadBodyRenderer(Renderer renderer, HashSet<Renderer> renderers)
		{
			if (!((Object)(object)renderer == (Object)null) && renderers != null && (renderer is MeshRenderer || renderer is SkinnedMeshRenderer))
			{
				renderers.Add(renderer);
			}
		}

		private static string GetTransformPath(Transform transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return "null";
			}
			Stack<string> stack = new Stack<string>();
			Transform val = transform;
			while ((Object)(object)val != (Object)null && stack.Count < 12)
			{
				stack.Push(((Object)val).name);
				val = val.parent;
			}
			return string.Join("/", stack);
		}

		private void ApplyToPlayer(PlayerControllerB player, SuitTextureState state)
		{
			RecordPlayerSuitSnapshot(player, "ApplyToPlayer(state)");
			if ((Object)(object)player == (Object)null || state == null || player.currentSuitID != state.SuitId)
			{
				return;
			}
			PlayerControllerB val = StartOfRound.Instance?.localPlayerController;
			bool flag = (Object)(object)val != (Object)null && player == val;
			if (flag && !DrawableSuitsPlugin.IsEditorOpen)
			{
				RestoreLocalPlayerMaterials("ApplyToPlayer skipped local closed editor");
			}
			else if (flag)
			{
				SetLocalRendererMaterial((Renderer)(object)player.thisPlayerModel, state.RuntimeMaterial);
				SetLocalRendererMaterial((Renderer)(object)player.thisPlayerModelLOD1, state.RuntimeMaterial);
				SetLocalRendererMaterial((Renderer)(object)player.thisPlayerModelLOD2, state.RuntimeMaterial);
				if (DrawableSuitsPlugin.ModConfig.ApplyLocalFirstPersonArms.Value)
				{
					SetLocalRendererMaterial((Renderer)(object)player.thisPlayerModelArms, state.RuntimeMaterial);
				}
				else
				{
					RestoreRendererToOriginal((Renderer)(object)player.thisPlayerModelArms, state.OriginalMaterial, "local first-person arms config disabled");
				}
			}
			else
			{
				SetRendererMaterial((Renderer)(object)player.thisPlayerModel, state.RuntimeMaterial);
				SetRendererMaterial((Renderer)(object)player.thisPlayerModelLOD1, state.RuntimeMaterial);
				SetRendererMaterial((Renderer)(object)player.thisPlayerModelLOD2, state.RuntimeMaterial);
			}
		}

		public int RestoreLocalPlayerMaterials(string reason)
		{
			int num = 0;
			if (_localRendererOriginalMaterials.Count > 0)
			{
				foreach (KeyValuePair<Renderer, Material[]> localRendererOriginalMaterial in _localRendererOriginalMaterials)
				{
					Renderer key = localRendererOriginalMaterial.Key;
					Material[] value = localRendererOriginalMaterial.Value;
					if (!((Object)(object)key == (Object)null) && value != null && value.Length != 0)
					{
						key.sharedMaterials = CloneMaterials(value);
						num++;
					}
				}
				_localRendererOriginalMaterials.Clear();
			}
			PlayerControllerB val = StartOfRound.Instance?.localPlayerController;
			SuitTextureState suitTextureState = (((Object)(object)val != (Object)null) ? GetOrCreateStateForPlayer(val, val.currentSuitID) : null);
			if ((Object)(object)val != (Object)null && (Object)(object)suitTextureState?.OriginalMaterial != (Object)null)
			{
				num += RestoreDrawableRendererFallback((Renderer)(object)val.thisPlayerModel, suitTextureState.OriginalMaterial, reason);
				num += RestoreDrawableRendererFallback((Renderer)(object)val.thisPlayerModelLOD1, suitTextureState.OriginalMaterial, reason);
				num += RestoreDrawableRendererFallback((Renderer)(object)val.thisPlayerModelLOD2, suitTextureState.OriginalMaterial, reason);
				num += RestoreDrawableRendererFallback((Renderer)(object)val.thisPlayerModelArms, suitTextureState.OriginalMaterial, reason);
			}
			if (num > 0)
			{
				DrawableSuitsDiagnostics.Info($"Restored local player materials. reason={reason}; restored={num}; applyLocalFirstPersonArms={DrawableSuitsPlugin.ModConfig.ApplyLocalFirstPersonArms.Value}");
			}
			return num;
		}

		private void SetLocalRendererMaterial(Renderer renderer, Material material)
		{
			if (!((Object)(object)renderer == (Object)null) && !((Object)(object)material == (Object)null))
			{
				if (!_localRendererOriginalMaterials.ContainsKey(renderer))
				{
					_localRendererOriginalMaterials[renderer] = CloneMaterials(renderer.sharedMaterials);
				}
				SetRendererMaterial(renderer, material);
			}
		}

		private void RestoreRendererToOriginal(Renderer renderer, Material fallbackMaterial, string reason)
		{
			if (!((Object)(object)renderer == (Object)null))
			{
				if (_localRendererOriginalMaterials.TryGetValue(renderer, out var value) && value != null && value.Length != 0)
				{
					renderer.sharedMaterials = CloneMaterials(value);
					_localRendererOriginalMaterials.Remove(renderer);
					DrawableSuitsDiagnostics.Info("Restored local renderer material. reason=" + reason + "; renderer=" + ((Object)renderer).name);
				}
				else
				{
					RestoreDrawableRendererFallback(renderer, fallbackMaterial, reason);
				}
			}
		}

		private static int RestoreDrawableRendererFallback(Renderer renderer, Material fallbackMaterial, string reason)
		{
			if ((Object)(object)renderer == (Object)null || (Object)(object)fallbackMaterial == (Object)null || !RendererUsesDrawableMaterial(renderer))
			{
				return 0;
			}
			renderer.sharedMaterial = fallbackMaterial;
			DrawableSuitsDiagnostics.Info("Restored DrawableSuits material fallback. reason=" + reason + "; renderer=" + ((Object)renderer).name + "; material=" + ((Object)fallbackMaterial).name);
			return 1;
		}

		private static bool RendererUsesDrawableMaterial(Renderer renderer)
		{
			if (((renderer != null) ? renderer.sharedMaterials : null) == null)
			{
				return false;
			}
			Material[] sharedMaterials = renderer.sharedMaterials;
			foreach (Material obj in sharedMaterials)
			{
				if ((((obj != null) ? ((Object)obj).name : null) ?? string.Empty).IndexOf("DrawableSuits", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		private static Material[] CloneMaterials(Material[] materials)
		{
			if (materials == null)
			{
				return Array.Empty<Material>();
			}
			Material[] array = (Material[])(object)new Material[materials.Length];
			Array.Copy(materials, array, materials.Length);
			return array;
		}

		private static void SetRendererMaterial(Renderer renderer, Material material)
		{
			if ((Object)(object)renderer != (Object)null && (Object)(object)material != (Object)null)
			{
				renderer.sharedMaterial = material;
			}
		}

		public static ulong GetPlayerClientId(PlayerControllerB player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return ResolveLocalClientId();
			}
			PlayerControllerB val = StartOfRound.Instance?.localPlayerController;
			if ((Object)(object)val != (Object)null && player == val)
			{
				return ResolveLocalClientId();
			}
			if (player.actualClientId != 0L || player.playerClientId == 0L)
			{
				return player.actualClientId;
			}
			return player.playerClientId;
		}

		public static int GetPlayerSlot(PlayerControllerB player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return -1;
			}
			PlayerControllerB[] array = StartOfRound.Instance?.allPlayerScripts;
			if (array == null)
			{
				return NormalizePlayerSlot((int)player.playerClientId);
			}
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i] == player)
				{
					return i;
				}
			}
			return NormalizePlayerSlot((int)player.playerClientId);
		}

		public static int ResolveLocalPlayerSlot()
		{
			return GetPlayerSlot(StartOfRound.Instance?.localPlayerController);
		}

		public static int ResolvePlayerSlotForClient(ulong ownerClientId)
		{
			PlayerControllerB[] array = StartOfRound.Instance?.allPlayerScripts;
			if (array == null)
			{
				return -1;
			}
			for (int i = 0; i < array.Length; i++)
			{
				PlayerControllerB val = array[i];
				if (!((Object)(object)val == (Object)null) && (GetPlayerClientId(val) == ownerClientId || val.actualClientId == ownerClientId || val.playerClientId == ownerClientId))
				{
					return i;
				}
			}
			return -1;
		}

		public static string DescribePlayerIdentity(PlayerControllerB player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return "player=null";
			}
			return $"player={player.playerUsername ?? ((Object)player).name}; slot={GetPlayerSlot(player)}; playerClientId={player.playerClientId}; actualClientId={player.actualClientId}; resolvedClientId={GetPlayerClientId(player)}; suitId={player.currentSuitID}";
		}

		internal static ulong ResolveLocalClientId()
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton != (Object)null && singleton.IsClient)
			{
				return singleton.LocalClientId;
			}
			PlayerControllerB val = StartOfRound.Instance?.localPlayerController;
			if (!((Object)(object)val != (Object)null))
			{
				return 0uL;
			}
			return val.actualClientId;
		}

		internal SuitTextureState NormalizeLocalStateOwner(SuitTextureState state, string context)
		{
			if (state == null || !state.IsPlayerSpecific || !state.IsLocalPlayerState)
			{
				return state;
			}
			ulong num = ResolveLocalClientId();
			int num2 = ResolveLocalPlayerSlot();
			if (state.OwnerClientId == num && state.OwnerPlayerSlot == num2)
			{
				return state;
			}
			ulong ownerClientId = state.OwnerClientId;
			int ownerPlayerSlot = state.OwnerPlayerSlot;
			string key = PlayerStateKey(ownerClientId, ownerPlayerSlot, state.SuitId);
			string key2 = PlayerStateKey(num, num2, state.SuitId);
			if (_playerStates.TryGetValue(key2, out var value) && value != state)
			{
				TextureTools.CopyInto(value.EditableTexture, state.EditableTexture);
				value.ActiveDesignName = state.ActiveDesignName;
				value.RuntimeMaterial.mainTexture = (Texture)(object)value.EditableTexture;
				value.IsLocalPlayerState = true;
				value.OwnerPlayerSlot = num2;
				RemovePlayerStateReferences(state);
				DrawableSuitsDiagnostics.Info($"Local suit texture state owner migrated by copy. context={context}; suitId={state.SuitId}; oldOwnerClientId={ownerClientId}; newOwnerClientId={num}; oldPlayerSlot={ownerPlayerSlot}; newPlayerSlot={num2}; oldStateDiscarded=True");
				return value;
			}
			_playerStates.Remove(key);
			state.OwnerClientId = num;
			state.OwnerPlayerSlot = num2;
			state.IsLocalPlayerState = true;
			if ((Object)(object)state.RuntimeMaterial != (Object)null)
			{
				Material runtimeMaterial = state.RuntimeMaterial;
				Material originalMaterial = state.OriginalMaterial;
				((Object)runtimeMaterial).name = string.Format("{0} (DrawableSuits client {1} slot {2})", ((originalMaterial != null) ? ((Object)originalMaterial).name : null) ?? "Suit material", num, num2);
			}
			_playerStates[key2] = state;
			DrawableSuitsDiagnostics.Info($"Local suit texture state owner migrated. context={context}; suitId={state.SuitId}; oldOwnerClientId={ownerClientId}; newOwnerClientId={num}; oldPlayerSlot={ownerPlayerSlot}; newPlayerSlot={num2}");
			return state;
		}

		private SuitTextureState TryMigrateLocalState(int suitId, ulong resolvedOwner, int resolvedSlot, string context)
		{
			SuitTextureState suitTextureState = null;
			foreach (KeyValuePair<string, SuitTextureState> playerState in _playerStates)
			{
				SuitTextureState value = playerState.Value;
				if (value != null && value.IsLocalPlayerState && value.SuitId == suitId && (value.OwnerClientId != resolvedOwner || value.OwnerPlayerSlot != resolvedSlot))
				{
					suitTextureState = value;
					break;
				}
			}
			if (suitTextureState == null)
			{
				return null;
			}
			return NormalizeLocalStateOwner(suitTextureState, context);
		}

		private void RemovePlayerStateReferences(SuitTextureState state)
		{
			if (state == null)
			{
				return;
			}
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, SuitTextureState> playerState in _playerStates)
			{
				if (playerState.Value == state)
				{
					list.Add(playerState.Key);
				}
			}
			foreach (string item in list)
			{
				_playerStates.Remove(item);
			}
		}

		private static bool IsOwnerLocal(ulong ownerClientId)
		{
			return ownerClientId == ResolveLocalClientId();
		}

		private static bool PlayerMatchesStateOwner(PlayerControllerB player, SuitTextureState state)
		{
			if ((Object)(object)player == (Object)null || state == null)
			{
				return false;
			}
			int playerSlot = GetPlayerSlot(player);
			if (state.OwnerPlayerSlot >= 0 && playerSlot == state.OwnerPlayerSlot)
			{
				return true;
			}
			return GetPlayerClientId(player) == state.OwnerClientId;
		}

		private static int NormalizePlayerSlot(int playerSlot)
		{
			if (playerSlot < 0 || playerSlot >= 64)
			{
				return -1;
			}
			return playerSlot;
		}

		private static UnlockableItem GetUnlockableItem(int suitId)
		{
			List<UnlockableItem> list = StartOfRound.Instance?.unlockablesList?.unlockables;
			if (list == null || suitId < 0 || suitId >= list.Count)
			{
				return null;
			}
			return list[suitId];
		}
	}
	internal sealed class SuitTextureState
	{
		public int SuitId;

		public ulong OwnerClientId;

		public int OwnerPlayerSlot = -1;

		public bool IsPlayerSpecific;

		public bool IsLocalPlayerState;

		public string SuitName;

		public Material OriginalMaterial;

		public Texture OriginalTexture;

		public Material RuntimeMaterial;

		public Texture2D BaseTexture;

		public Texture2D EditableTexture;

		public string ActiveDesignName;
	}
	internal static class TextureTools
	{
		public static Texture2D CreateEditableCopy(Texture source, int maxSize)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_0069: 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)
			int num = Mathf.Clamp(((Object)(object)source != (Object)null) ? source.width : maxSize, 64, maxSize);
			int num2 = Mathf.Clamp(((Object)(object)source != (Object)null) ? source.height : maxSize, 64, maxSize);
			Texture2D val = new Texture2D(num, num2, (TextureFormat)4, false);
			((Object)val).name = "DrawableSuitsEditableTexture";
			if ((Object)(object)source == (Object)null)
			{
				Fill(val, new Color32((byte)180, (byte)180, (byte)180, byte.MaxValue));
				return val;
			}
			RenderTexture active = RenderTexture.active;
			RenderTexture temporary = RenderTexture.GetTemporary(num, num2, 0, (RenderTextureFormat)0);
			try
			{
				Graphics.Blit(source, temporary);
				RenderTexture.active = temporary;
				val.ReadPixels(new Rect(0f, 0f, (float)num, (float)num2), 0, 0);
				val.Apply(false, false);
				return val;
			}
			finally
			{
				RenderTexture.active = active;
				RenderTexture.ReleaseTemporary(temporary);
			}
		}

		public static Texture2D LoadImageFile(string path, int maxSize)
		{
			return LoadImageBytes(File.ReadAllBytes(path), Path.GetFileNameWithoutExtension(path), maxSize);
		}

		public static Texture2D LoadImageBytes(byte[] bytes, string name, int maxSize, bool resizeOversized = true)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Expected O, but got Unknown
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
			if (!ImageConversion.LoadImage(val, bytes, false))
			{
				Object.Destroy((Object)(object)val);
				return null;
			}
			((Object)val).name = (string.IsNullOrWhiteSpace(name) ? "DrawableSuitsImage" : name);
			if (((Texture)val).width <= maxSize && ((Texture)val).height <= maxSize)
			{
				return val;
			}
			if (!resizeOversized)
			{
				Object.Destroy((Object)(object)val);
				return null;
			}
			Texture2D obj = Resize((Texture)(object)val, maxSize, maxSize);
			((Object)obj).name = ((Object)val).name;
			Object.Destroy((Object)(object)val);
			return obj;
		}

		public static Texture2D Resize(Texture source, int width, int height)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(width, height, (TextureFormat)4, false);
			RenderTexture active = RenderTexture.active;
			RenderTexture temporary = RenderTexture.GetTemporary(width, height, 0, (RenderTextureFormat)0);
			try
			{
				Graphics.Blit(source, temporary);
				RenderTexture.active = temporary;
				val.ReadPixels(new Rect(0f, 0f, (float)width, (float)height), 0, 0);
				val.Apply(false, false);
				return val;
			}
			finally
			{
				RenderTexture.active = active;
				RenderTexture.ReleaseTemporary(temporary);
			}
		}

		public static void Fill(Texture2D texture, Color32 color)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			Color32[] array = (Color32[])(object)new Color32[((Texture)texture).width * ((Texture)texture).height];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = color;
			}
			texture.SetPixels32(array);
			texture.Apply(false, false);
		}

		public static void CopyInto(Texture2D target, Texture2D source)
		{
			Texture2D val = ((((Texture)source).width == ((Texture)target).width && ((Texture)source).height == ((Texture)target).height) ? source : Resize((Texture)(object)source, ((Texture)target).width, ((Texture)target).height));
			target.SetPixels32(val.GetPixels32());
			target.Apply(false, false);
			if (val != source)
			{
				Object.Destroy((Object)(object)val);
			}
		}

		public static string SanitizeFileName(string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return "DrawableSuit";
			}
			char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
			foreach (char oldChar in invalidFileNameChars)
			{
				value = value.Replace(oldChar, '_');
			}
			return value.Trim();
		}

		public static bool IsImagePath(string path)
		{
			string extension = Path.GetExtension(path);
			if (!extension.Equals(".png", StringComparison.OrdinalIgnoreCase) && !extension.Equals(".jpg", StringComparison.OrdinalIgnoreCase))
			{
				return extension.Equals(".jpeg", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}
	}
}