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.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.Json;
using BabyBlocks;
using BabyBlocks.Networking;
using BabyBlocks.UI;
using BabyStepsMenuLib;
using HarmonyLib;
using Il2Cpp;
using Il2CppBeautifyEffect;
using Il2CppCinemachine;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Attributes;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppNWH.DWP2.WaterObjects;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.Reflection;
using Il2CppTMPro;
using MelonLoader;
using MelonLoader.Preferences;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UniverseLib;
using UniverseLib.Config;
using UniverseLib.UI;
using UniverseLib.UI.Models;
using UniverseLib.UI.Panels;
using UniverseLib.UI.Widgets;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Core), "Baby Blocks", "1.0.1", "Caleb Orchard", null)]
[assembly: MelonGame("DefaultCompany", "BabySteps")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("BabyBlocks")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.1")]
[assembly: AssemblyInformationalVersion("1.0.0+6bca26d40e0aea8157b6afaae13e39037c1f65c7")]
[assembly: AssemblyProduct("BabyBlocks")]
[assembly: AssemblyTitle("BabyBlocks")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 BabyBlocks
{
	public class Core : MelonMod
	{
		public static bool DebugMode = false;

		private static MelonPreferences_Category _prefs;

		private static MelonPreferences_Entry<string> _lastSavePath;

		private static FieldInfo _mpUiManagerField;

		private static FieldInfo _mpShowChatTabField;

		private static bool _mpReflectionDone;

		private const float SomebodyLoadingStuckTimeout = 6f;

		private static bool _somebodyLoadingWasTrue;

		private static float _somebodyLoadingSinceTime;

		private const float MenuTeleportingStuckTimeout = 8f;

		private static bool _menuTeleportingWasTrue;

		private static float _menuTeleportingSinceTime;

		internal static float PendingMicroSplatRefreshTime = -1f;

		internal const float MicroSplatRefreshSettleDelay = 1.5f;

		private static bool _wasFarTeleportActive;

		private const int PostTeleportRescanFrames = 90;

		private static int _postTeleportRescanFramesRemaining;

		private static bool _networkingDisabled;

		public static Instance Logger { get; private set; }

		public static bool IsMultiplayerChatOpen
		{
			get
			{
				EnsureMpReflection();
				if (_mpUiManagerField == null)
				{
					return false;
				}
				try
				{
					object value = _mpUiManagerField.GetValue(null);
					return value != null && (bool)_mpShowChatTabField.GetValue(value);
				}
				catch
				{
					return false;
				}
			}
		}

		public static bool IsKeyboardCaptured => IsMultiplayerChatOpen || ((Object)(object)Menu.me != (Object)null && Menu.me.paused);

		public static string LastSavePath
		{
			get
			{
				return _lastSavePath?.Value ?? "";
			}
			set
			{
				if (_lastSavePath != null)
				{
					_lastSavePath.Value = value;
					_prefs.SaveToFile(true);
				}
			}
		}

		private static void EnsureMpReflection()
		{
			if (_mpReflectionDone)
			{
				return;
			}
			_mpReflectionDone = true;
			try
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					if (!(assembly.GetName().Name != "BabyStepsMultiplayerClient"))
					{
						FieldInfo fieldInfo = assembly.GetType("BabyStepsMultiplayerClient.Core")?.GetField("uiManager", BindingFlags.Static | BindingFlags.Public);
						FieldInfo fieldInfo2 = fieldInfo?.FieldType.GetField("showChatTab", BindingFlags.Instance | BindingFlags.Public);
						if (fieldInfo != null && fieldInfo2 != null)
						{
							_mpUiManagerField = fieldInfo;
							_mpShowChatTabField = fieldInfo2;
						}
						break;
					}
				}
			}
			catch
			{
			}
		}

		private static void WatchSomebodyLoading()
		{
			if ((Object)(object)BestRegionLoader.me == (Object)null || FlyCamController.FarTeleportActive)
			{
				return;
			}
			if (BestRegionLoader.somebodyLoading)
			{
				if (!_somebodyLoadingWasTrue)
				{
					_somebodyLoadingWasTrue = true;
					_somebodyLoadingSinceTime = Time.realtimeSinceStartup;
				}
				else if (Time.realtimeSinceStartup - _somebodyLoadingSinceTime > 6f)
				{
					MelonLogger.Warning($"[BabyBlocks] BestRegionLoader.somebodyLoading stuck for {6f}s, force-clearing.");
					BestRegionLoader.somebodyLoading = false;
					_somebodyLoadingWasTrue = false;
				}
			}
			else
			{
				_somebodyLoadingWasTrue = false;
			}
		}

		private static void WatchMenuTeleporting()
		{
			if ((Object)(object)Menu.me == (Object)null)
			{
				return;
			}
			if (FlyCamController.FarTeleportActive || FlyCamController.LevelLoadTeleportActive || FlyCamController.NetworkLevelTransferActive)
			{
				_menuTeleportingWasTrue = false;
			}
			else if (Menu.me.teleporting)
			{
				if (!_menuTeleportingWasTrue)
				{
					_menuTeleportingWasTrue = true;
					_menuTeleportingSinceTime = Time.realtimeSinceStartup;
				}
				else if (Time.realtimeSinceStartup - _menuTeleportingSinceTime > 8f)
				{
					MelonLogger.Warning($"[BabyBlocks] Menu.me.teleporting stuck true for {8f}s, force-clearing.");
					Menu.me.teleporting = false;
					_menuTeleportingWasTrue = false;
				}
			}
			else
			{
				_menuTeleportingWasTrue = false;
			}
		}

		public override void OnInitializeMelon()
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			Logger = ((MelonBase)this).LoggerInstance;
			_prefs = MelonPreferences.CreateCategory("BabyBlocks");
			_lastSavePath = _prefs.CreateEntry<string>("LastSavePath", "", (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			ClassInjector.RegisterTypeInIl2Cpp<LevelEditorObject>();
			ClassInjector.RegisterTypeInIl2Cpp<LevelEditorManager>();
			ClassInjector.RegisterTypeInIl2Cpp<GizmoHandle>();
			ClassInjector.RegisterTypeInIl2Cpp<GhostCollisionCutter>();
			ClassInjector.RegisterTypeInIl2Cpp<SpawnPointMarker>();
			ClassInjector.RegisterTypeInIl2Cpp<OverlayCamPreRenderHook>();
			ClassInjector.RegisterTypeInIl2Cpp<BbSunglassesChecker>();
			Harmony val = new Harmony("BabyBlocks.Patches");
			val.PatchAll(Assembly.GetExecutingAssembly());
			val.PatchAll(typeof(MenuInjectionLibrary).Assembly);
			MenuInjectionLibrary.Logger = Logger;
			CustomLevelsMenu.Initialize();
			PropBrowserUI.Init();
		}

		public override void OnSceneWasLoaded(int buildIndex, string sceneName)
		{
			MaterialVariantTracker.InvalidateMaterialCache();
			PendingMicroSplatRefreshTime = Time.realtimeSinceStartup;
		}

		public override void OnUpdate()
		{
			CustomLevelsMenu.Update();
			WatchSomebodyLoading();
			WatchMenuTeleporting();
			if (!_networkingDisabled)
			{
				try
				{
					ModNetworking.Update();
				}
				catch (Exception ex)
				{
					_networkingDisabled = true;
					MelonLogger.Warning("[BabyBlocks] Networking unavailable, disabling: " + ex.Message);
				}
			}
			FlyCamController.OnUpdate();
			PropBrowserUI.UpdateVisibility();
			PropInstanceServices.RenderTints();
			BaseMapController.TickWeatherPreset();
			if (!BaseMapController.BaseMapEnabled && !FlyCamController.FarTeleportActive)
			{
				if (_wasFarTeleportActive)
				{
					_postTeleportRescanFramesRemaining = 90;
				}
				_wasFarTeleportActive = false;
				BestRegionLoader me = BestRegionLoader.me;
				if ((Object)(object)me != (Object)null)
				{
					if (_postTeleportRescanFramesRemaining > 0)
					{
						BaseMapController.RescanLoadedChunksForBaseMapOff();
						_postTeleportRescanFramesRemaining--;
					}
					if (!me.off && !BaseMapController.DeferBrlOff && _postTeleportRescanFramesRemaining == 0)
					{
						me.off = true;
					}
					Renderer[] brlRendererCache = BaseMapController._brlRendererCache;
					bool flag = false;
					Renderer[] array = brlRendererCache;
					foreach (Renderer val in array)
					{
						if ((Object)(object)val == (Object)null)
						{
							flag = true;
							break;
						}
						if (val.enabled)
						{
							val.enabled = false;
						}
					}
					if (flag)
					{
						BaseMapController._brlRendererCache = Il2CppArrayBase<Renderer>.op_Implicit(((Component)me).GetComponentsInChildren<Renderer>(true));
					}
				}
				BaseMapController.SuppressHiddenWhileBaseMapOff();
			}
			else if (FlyCamController.FarTeleportActive)
			{
				_wasFarTeleportActive = true;
			}
		}

		public override void OnLateUpdate()
		{
			PropBrowserUI.RestoreCursor();
		}

		public override void OnGUI()
		{
			FlyCamController.OnGUI();
			HatPreviewRenderer.DrawWindowGUI();
		}
	}
	[HarmonyPatch(typeof(FlyCam), "Update")]
	internal class FlyCamUpdatePatch
	{
		private static bool Prefix(FlyCam __instance)
		{
			//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_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_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_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_0071: 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_01e0: 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_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_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_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_018f: 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)
			//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_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_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_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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: 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)
			if (FlyCam.locked)
			{
				return false;
			}
			bool flag = FlyCamController.CursorMode && (LevelEditor.IsTypingInUI || Core.IsKeyboardCaptured);
			Vector3 val = Vector3.zero;
			if (!flag)
			{
				if (Input.GetKey((KeyCode)119))
				{
					val += Vector3.forward;
				}
				if (Input.GetKey((KeyCode)115))
				{
					val += Vector3.back;
				}
				if (Input.GetKey((KeyCode)100))
				{
					val += Vector3.right;
				}
				if (Input.GetKey((KeyCode)97))
				{
					val += Vector3.left;
				}
				if (Input.GetKey((KeyCode)101))
				{
					val += Vector3.up;
				}
				if (Input.GetKey((KeyCode)113))
				{
					val += Vector3.down;
				}
				if (Input.GetKey((KeyCode)304))
				{
					val *= 10f;
				}
				if (Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)308))
				{
					val *= 30f;
				}
			}
			if (!FlyCamController.CursorMode || (Input.GetMouseButton(1) && !LevelEditor.isDragging))
			{
				Vector3 eulerAngles = ((Component)__instance).transform.eulerAngles;
				if (eulerAngles.x > 180f)
				{
					eulerAngles.x -= 360f;
				}
				eulerAngles.x -= Input.GetAxis("Mouse Y");
				eulerAngles.x = Mathf.Clamp(eulerAngles.x, -85f, 85f);
				eulerAngles.y += Input.GetAxis("Mouse X");
				((Component)__instance).transform.eulerAngles = eulerAngles;
			}
			Transform transform = ((Component)__instance).transform;
			transform.position += ((Component)__instance).transform.rotation * (val * __instance.maxVel) * Time.unscaledDeltaTime;
			if (!FlyCamController.CursorMode && Input.GetMouseButtonDown(0) && !Menu.me.paused)
			{
				FlyCamController.HandleFarTeleport();
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(CinemachineBrain), "LateUpdate")]
	internal class CinemachineBrainLateUpdatePatch
	{
		private static void Postfix(CinemachineBrain __instance)
		{
			if (!BaseMapController.BaseMapEnabled)
			{
				__instance.ManualUpdate();
			}
			GizmoRenderer.RefreshSSBufferMatrices();
		}
	}
	[HarmonyPatch(typeof(BBConvoStarter), "OnTriggerEnter")]
	internal class BBConvoStarterTriggerPatch
	{
		private static bool Prefix(BBConvoStarter __instance)
		{
			bool suppressCutsceneTriggers = FlyCamController.SuppressCutsceneTriggers;
			return !suppressCutsceneTriggers;
		}
	}
	[HarmonyPatch(typeof(BBConvoStarter), "PlayCutscene")]
	internal class BBConvoStarterPlayCutscenePatch
	{
		private static bool Prefix(BBConvoStarter __instance)
		{
			bool suppressCutsceneTriggers = FlyCamController.SuppressCutsceneTriggers;
			if (suppressCutsceneTriggers)
			{
				FlyCamController.RegisterSuppressedCutscene(__instance);
			}
			return !suppressCutsceneTriggers;
		}
	}
	[HarmonyPatch(typeof(TractionByteKeeper), "GetGrassAt")]
	internal class TractionByteKeeperGetGrassAtPatch
	{
		private static bool Prefix(Vector3 pos, ref GrassType __result)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			int grassTypeAtPos = PropInstanceServices.BushAudioTracker.GetGrassTypeAtPos(pos);
			if (grassTypeAtPos != 0)
			{
				__result = (GrassType)grassTypeAtPos;
				return false;
			}
			return true;
		}
	}
	internal static class BBLog
	{
		internal static bool Verbose;

		internal static void Msg(string msg)
		{
			if (Verbose)
			{
				MelonLogger.Msg(msg);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerMovement), "PlaceCurrentHatOnHead")]
	internal class PlaceCurrentHatOnHeadPatch
	{
		private static bool Prefix(PlayerMovement __instance)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: 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)
			if ((Object)(object)__instance.currentHat == (Object)null)
			{
				return true;
			}
			LevelEditorObject levelEditorObject = ((Component)__instance.currentHat).GetComponent<LevelEditorObject>() ?? ((Component)__instance.currentHat).GetComponentInChildren<LevelEditorObject>();
			if ((Object)(object)levelEditorObject == (Object)null)
			{
				return true;
			}
			Transform transform = ((Component)__instance.currentHat).transform;
			transform.parent = (__instance.inCutscene ? __instance.head : __instance.headRB);
			transform.localPosition = new Vector3(0f, 0.207f, -0.02f) + levelEditorObject.hatOffsetPos;
			transform.localRotation = Quaternion.Euler(-25f + levelEditorObject.hatOffsetRot.x, levelEditorObject.hatOffsetRot.y, levelEditorObject.hatOffsetRot.z);
			if (!__instance.inCutscene)
			{
				transform.parent = null;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(SunglassesChecker), "Update")]
	internal class SunglassesCheckerUpdatePatch
	{
		private static readonly HashSet<int> _forcedVisible = new HashSet<int>();

		private static void Postfix(SunglassesChecker __instance)
		{
			bool flyCamActive = FlyCamController.FlyCamActive;
			int instanceID = ((Object)__instance).GetInstanceID();
			if (flyCamActive)
			{
				_forcedVisible.Add(instanceID);
				SetRends(__instance, enabled: true);
			}
			else if (_forcedVisible.Remove(instanceID))
			{
				bool enabled = BbSunglassesChecker.IsWearingSunglasses();
				SetRends(__instance, enabled);
			}
		}

		private static void SetRends(SunglassesChecker instance, bool enabled)
		{
			try
			{
				FieldInfo field = ((Object)instance).GetIl2CppType().GetField("rends");
				if (field != (FieldInfo)null)
				{
					Object value = field.GetValue(((Il2CppObjectBase)instance).Cast<Object>());
					Il2CppReferenceArray<Renderer> val = ((value != null) ? ((Il2CppObjectBase)value).TryCast<Il2CppReferenceArray<Renderer>>() : null);
					if (val != null)
					{
						foreach (Renderer item in (Il2CppArrayBase<Renderer>)(object)val)
						{
							if ((Object)(object)item != (Object)null)
							{
								item.enabled = enabled;
							}
						}
						return;
					}
				}
			}
			catch
			{
			}
			foreach (Renderer componentsInChild in ((Component)instance).GetComponentsInChildren<Renderer>(true))
			{
				if ((Object)(object)componentsInChild != (Object)null)
				{
					componentsInChild.enabled = enabled;
				}
			}
		}
	}
	public enum PhysicsMode
	{
		Static,
		Rigidbody,
		Grabable,
		Hat
	}
	public class LevelEditorObject : MonoBehaviour
	{
		public string objectType = "Cube";

		public string addressableKey = "";

		public int chunkIndex = -1;

		public Vector2Int chunkCoord = new Vector2Int(-1, -1);

		public Vector3 loopBasePosition;

		public Quaternion loopBaseRotation = Quaternion.identity;

		public Vector3 loopBaseScale = Vector3.one;

		public bool hasLoopBasePosition;

		public bool hasLoopBaseRotation;

		public bool hasLoopBaseScale;

		public PhysicsMode physicsMode = PhysicsMode.Static;

		public float hatHairAmt = 0f;

		public int groupId = 0;

		public int physicsGroupId = 0;

		public bool isPhysicsManaged;

		public bool editorFreezeStateValid;

		public Vector3 editorFreezePosition;

		public Quaternion editorFreezeRotation;

		public Vector3 editorFreezeScale;

		public Vector3 editorFreezeVelocity;

		public Vector3 editorFreezeAngularVelocity;

		public bool editorFreezeIsKinematic;

		public bool editorFreezeUseGravity;

		public RigidbodyConstraints editorFreezeConstraints;

		public Vector3 grabOffsetPos = Vector3.zero;

		public Vector3 grabOffsetRot = Vector3.zero;

		public Vector3 hatOffsetPos = Vector3.zero;

		public Vector3 hatOffsetRot = Vector3.zero;

		public int materialConstructionId = -1;

		public bool sunglassesNeeded;

		public bool playerPassthrough;

		public bool freezeUntilHit;

		public string surfaceTypeTag = "";

		public Vector3 materialTint = new Vector3(255f, 255f, 255f);

		internal Renderer[] _tintRenderers;

		internal Material _tintMaterial;

		public ulong netId = 0uL;

		public LevelEditorObject(IntPtr ptr)
			: base(ptr)
		{
		}//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_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_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: 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_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)


		public void OnCollisionEnter(Collision collision)
		{
			if (!freezeUntilHit || !PhysicsObjectManager.HasFreezeUntilHit(this))
			{
				return;
			}
			Rigidbody rigidbody = collision.rigidbody;
			int layer = ((Component)collision.collider).gameObject.layer;
			bool flag = layer == LayerCache.RagdollLayer;
			bool flag2 = (Object)(object)rigidbody != (Object)null && !rigidbody.isKinematic && (Object)(object)((Component)rigidbody).GetComponentInParent<LevelEditorObject>(true) != (Object)null;
			if (flag || flag2)
			{
				PhysicsObjectManager.OnFreezeUntilHitTriggered(this);
				PhysicsObjectManager.UnfreezeHitProp(this, collision);
				if (netId != 0)
				{
					ModNetworking.SendPropFreezeReleased(netId);
				}
			}
		}
	}
	public class GizmoHandle : MonoBehaviour
	{
		public int axisIndex;

		public GizmoHandle(IntPtr ptr)
			: base(ptr)
		{
		}
	}
	internal class OverlayCamPreRenderHook : MonoBehaviour
	{
		public OverlayCamPreRenderHook(IntPtr ptr)
			: base(ptr)
		{
		}

		public void OnPreRender()
		{
			GizmoRenderer.RefreshSSBufferMatrices();
		}
	}
	internal class BbSunglassesChecker : MonoBehaviour
	{
		private bool[] _wasEnabled;

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

		public static bool IsWearingSunglasses()
		{
			if (FlyCamController.FlyCamActive)
			{
				return true;
			}
			PlayerMovement me = PlayerMovement.me;
			return (Object)(object)me != (Object)null && (Object)(object)me.currentHat != (Object)null && me.currentHat.isSunglasses && !me.inCutscene;
		}

		private void Awake()
		{
			Il2CppArrayBase<Renderer> componentsInChildren = ((Component)this).GetComponentsInChildren<Renderer>(true);
			_wasEnabled = new bool[componentsInChildren.Length];
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				_wasEnabled[i] = (Object)(object)componentsInChildren[i] != (Object)null && componentsInChildren[i].enabled;
			}
		}

		private void Update()
		{
			if (_wasEnabled == null)
			{
				return;
			}
			bool enabled = IsWearingSunglasses();
			Il2CppArrayBase<Renderer> componentsInChildren = ((Component)this).GetComponentsInChildren<Renderer>(true);
			int num = Math.Min(componentsInChildren.Length, _wasEnabled.Length);
			for (int i = 0; i < num; i++)
			{
				if (!((Object)(object)componentsInChildren[i] == (Object)null) && _wasEnabled[i])
				{
					componentsInChildren[i].enabled = enabled;
				}
			}
		}
	}
	internal static class BbHatSunglassesFlag
	{
		private static readonly HashSet<int> _ids = new HashSet<int>();

		internal static void Clear()
		{
			_ids.Clear();
		}

		internal static void Set(LevelEditorObject leo, bool on)
		{
			if (!((Object)(object)((leo != null) ? ((Component)leo).gameObject : null) == (Object)null))
			{
				int instanceID = ((Object)((Component)leo).gameObject).GetInstanceID();
				if (on)
				{
					_ids.Add(instanceID);
				}
				else
				{
					_ids.Remove(instanceID);
				}
			}
		}

		internal static bool Has(LevelEditorObject leo)
		{
			return (Object)(object)((leo != null) ? ((Component)leo).gameObject : null) != (Object)null && _ids.Contains(((Object)((Component)leo).gameObject).GetInstanceID());
		}
	}
	internal static class FlyCamController
	{
		public static bool FlyCamActive;

		public static bool CursorMode;

		public static bool LevelLoadTeleportActive;

		public static bool NetworkLevelTransferActive;

		private const float CutsceneSuppressGraceTime = 0.3f;

		private static float _cutsceneSuppressUntil = -1f;

		private static readonly List<BBConvoStarter> _pendingCutscenes = new List<BBConvoStarter>();

		private static float _noiseAmplitude = -1f;

		private static bool _editorScanDone;

		private static EnviroSkyRendering _enviroSkyRendering;

		private static Beautify _beautify;

		private static bool _farTeleportActive;

		private static Transform _teleportLoadAnchor;

		private static bool _freezeActive;

		private static PlayerMovement _frozenPlayer;

		private static CharacterController _frozenController;

		private static Rigidbody _frozenRigidbody;

		private static Animator _frozenAnimator;

		private static bool _movementWasEnabled;

		private static bool _controllerWasEnabled;

		private static bool _rigidbodyWasKinematic;

		private static bool _rigidbodyWasUseGravity;

		private static RigidbodyConstraints _rigidbodyConstraints;

		private static Vector3 _rigidbodyVelocity;

		private static Vector3 _rigidbodyAngularVelocity;

		private static float _animatorSpeed = 1f;

		private static GUIStyle _teleportLabelStyle;

		public static bool SuppressCutsceneTriggers => FlyCamActive || !BaseMapController.BaseMapEnabled || Time.unscaledTime < _cutsceneSuppressUntil;

		internal static bool FarTeleportActive => _farTeleportActive;

		private static Transform TeleportLoadAnchor
		{
			get
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Expected O, but got Unknown
				if ((Object)(object)_teleportLoadAnchor == (Object)null)
				{
					GameObject val = new GameObject("BB_TeleportLoadAnchor");
					Object.DontDestroyOnLoad((Object)(object)val);
					_teleportLoadAnchor = val.transform;
				}
				return _teleportLoadAnchor;
			}
		}

		public static void BeginLevelLoadTeleport()
		{
			LevelLoadTeleportActive = true;
		}

		public static void EndLevelLoadTeleport()
		{
			LevelLoadTeleportActive = false;
		}

		public static void BeginNetworkLevelTransfer()
		{
			NetworkLevelTransferActive = true;
		}

		public static void EndNetworkLevelTransfer()
		{
			NetworkLevelTransferActive = false;
		}

		public static void RegisterSuppressedCutscene(BBConvoStarter bcs)
		{
			if ((Object)(object)bcs == (Object)null)
			{
				return;
			}
			string saveName = bcs.GetSaveName();
			foreach (BBConvoStarter pendingCutscene in _pendingCutscenes)
			{
				if ((Object)(object)pendingCutscene != (Object)null && pendingCutscene.GetSaveName() == saveName)
				{
					return;
				}
			}
			_pendingCutscenes.Add(bcs);
		}

		private static void ReplaySuppressedCutscenes()
		{
			if (_pendingCutscenes.Count == 0 || SuppressCutsceneTriggers)
			{
				return;
			}
			List<BBConvoStarter> list = new List<BBConvoStarter>(_pendingCutscenes);
			_pendingCutscenes.Clear();
			foreach (BBConvoStarter item in list)
			{
				if (!((Object)(object)item == (Object)null))
				{
					item.PlayCutscene();
				}
			}
		}

		private static void SetEditorPostProcessing(bool enabled)
		{
			if ((Object)(object)_enviroSkyRendering == (Object)null || (Object)(object)_beautify == (Object)null)
			{
				GameObject obj = GameObject.Find("BigManagerPrefab");
				Transform val = ((obj != null) ? obj.transform.Find("Camera") : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				_enviroSkyRendering = ((Component)val).GetComponent<EnviroSkyRendering>();
				_beautify = ((Component)val).GetComponent<Beautify>();
			}
			if ((Object)(object)_enviroSkyRendering != (Object)null)
			{
				((Behaviour)_enviroSkyRendering).enabled = enabled;
			}
			if ((Object)(object)_beautify != (Object)null)
			{
				((Behaviour)_beautify).enabled = enabled;
			}
		}

		public static void OnUpdate()
		{
			ReplaySuppressedCutscenes();
			if (Core.PendingMicroSplatRefreshTime >= 0f && Time.realtimeSinceStartup - Core.PendingMicroSplatRefreshTime >= 1.5f)
			{
				Core.PendingMicroSplatRefreshTime = -1f;
				MaterialCatalog.RefreshMicroSplatLayerMaterials();
				MaterialVariantTracker.InvalidateMaterialCache();
				MaterialCatalog.EnsureMaterialListLoaded();
				MaterialCatalog.ReapplyAllMaterialOverrides();
				if (!BaseMapController.BaseMapEnabled)
				{
					BaseMapController.SetEditorPropsSnowDisabled(disable: true);
				}
				LevelEditorManager.Instance?.PruneDestroyedObjects();
				LevelEditor.PruneSelection();
				if (GizmoRenderer.IsReady)
				{
					GizmoRenderer.RefreshAssets();
				}
			}
			if (Input.GetKeyDown((KeyCode)114) && (Object)(object)PlayerMovement.me != (Object)null && !Menu.me.teleporting && !_farTeleportActive && !Core.IsKeyboardCaptured && !LevelEditor.IsTypingInUI && !PropPalette.IsDragging && !LevelEditor.IsSurfaceSnapDragging && !PlayerMovement.me.inCutscene)
			{
				ToggleFlyEditorMode();
			}
			if (Input.GetKeyDown((KeyCode)96) && (Object)(object)PlayerMovement.me != (Object)null && !Menu.me.teleporting && !_farTeleportActive && !Core.IsKeyboardCaptured && !PlayerMovement.me.inCutscene)
			{
				ToggleTeleportMode();
			}
			if (FlyCamActive && !CursorMode && Input.GetKeyDown((KeyCode)103) && !Menu.me.teleporting && !_farTeleportActive && !Core.IsKeyboardCaptured)
			{
				HandleFarTeleport();
			}
			if (FlyCamActive && !Menu.me.teleporting)
			{
				PlayerMovement me = PlayerMovement.me;
				if ((Object)(object)me != (Object)null)
				{
					BestRegionLoader.me.loadingTransform = ((Component)me.flyCam).transform;
				}
			}
			if (FlyCamActive && CursorMode)
			{
				if (Input.GetMouseButtonDown(1))
				{
					Cursor.lockState = (CursorLockMode)1;
					Cursor.visible = false;
				}
				if (Input.GetMouseButtonUp(1))
				{
					Cursor.lockState = (CursorLockMode)2;
					Cursor.visible = true;
				}
			}
			if (FlyCamActive && CursorMode && !LevelEditor.IsTypingInUI && !Core.IsKeyboardCaptured && Input.GetKey((KeyCode)306) && Input.GetKeyDown((KeyCode)115))
			{
				SaveLoadWindow.TriggerSave();
			}
			if (FlyCamActive && CursorMode && !LevelEditor.IsTypingInUI && !Core.IsKeyboardCaptured && Input.GetKey((KeyCode)306) && Input.GetKeyDown((KeyCode)97))
			{
				LevelEditor.SelectAll();
			}
			if (FlyCamActive && CursorMode && !LevelEditor.IsTypingInUI && !Core.IsKeyboardCaptured && Input.GetKeyDown((KeyCode)109))
			{
				MaterialInspectorPanel.Toggle();
			}
			if (FlyCamActive && CursorMode)
			{
				LevelEditor.Update();
			}
		}

		public static void OnGUI()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_008a: 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_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_013f: 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)
			if (FlyCamActive && CursorMode && (!PropBrowserUI.Ready || Core.DebugMode))
			{
				LevelEditor.OnGUI();
			}
			bool flag = _farTeleportActive || LevelLoadTeleportActive;
			bool networkLevelTransferActive = NetworkLevelTransferActive;
			if (flag || networkLevelTransferActive)
			{
				if (_teleportLabelStyle == null)
				{
					_teleportLabelStyle = new GUIStyle(GUI.skin.label)
					{
						fontSize = 48,
						fontStyle = (FontStyle)1
					};
					_teleportLabelStyle.normal.textColor = Color.white;
				}
				string text = ((networkLevelTransferActive && !flag) ? "Loading level..." : "Teleporting...");
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(13f, (float)Screen.height - 12f - 60f + 1f, 400f, 60f);
				Rect val2 = default(Rect);
				((Rect)(ref val2))..ctor(12f, (float)Screen.height - 12f - 60f, 400f, 60f);
				Color textColor = _teleportLabelStyle.normal.textColor;
				_teleportLabelStyle.normal.textColor = Color.black;
				GUI.Label(val, text, _teleportLabelStyle);
				_teleportLabelStyle.normal.textColor = textColor;
				GUI.Label(val2, text, _teleportLabelStyle);
			}
		}

		private static void ToggleTeleportMode()
		{
			if (!FlyCamActive)
			{
				ToggleFlyMode();
				ToggleCursorMode();
			}
			else
			{
				ToggleFlyMode();
			}
		}

		public static void InvokeRKeyAction()
		{
			if (!((Object)(object)PlayerMovement.me == (Object)null) && !((Object)(object)Menu.me == (Object)null) && !Menu.me.teleporting && !_farTeleportActive && !PlayerMovement.me.inCutscene)
			{
				ToggleFlyEditorMode();
			}
		}

		private static void ToggleFlyEditorMode()
		{
			if (!FlyCamActive)
			{
				ToggleFlyMode();
			}
			else
			{
				ToggleCursorMode();
			}
		}

		private static void ToggleFlyMode()
		{
			PlayerMovement me = PlayerMovement.me;
			bool flag = (Object)(object)((Component)me.flyCam).transform.parent != (Object)null;
			me.ToggleFlyCam();
			if (flag)
			{
				FlyCamActive = true;
				CursorMode = false;
				Cursor.lockState = (CursorLockMode)1;
				FreezePlayer(me, frozen: true);
				LevelEditor.EnsureManager();
				if (!_editorScanDone)
				{
					MaterialCatalog.MarkMaterialSourcesPending();
				}
				MelonCoroutines.Start(ActivateEditorScanCo());
				CinemachineBasicMultiChannelPerlin componentInChildren = ((Component)me.flyCam).GetComponentInChildren<CinemachineBasicMultiChannelPerlin>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					if (_noiseAmplitude < 0f)
					{
						_noiseAmplitude = componentInChildren.m_AmplitudeGain;
					}
					componentInChildren.m_AmplitudeGain = 0f;
				}
				return;
			}
			if ((Object)(object)LevelEditorManager.Instance != (Object)null)
			{
				PhysicsObjectManager.SetEditorModeActive(active: false);
			}
			CursorMode = false;
			Cursor.lockState = (CursorLockMode)1;
			Cursor.visible = false;
			SetEditorPostProcessing(enabled: true);
			FreezePlayer(me, frozen: false);
			me.pm.SwitchToActiveMode();
			me.pm.SwitchModes();
			me.OnStandUp();
			LevelEditor.HideGizmo();
			LevelEditor.ClearRemoteSelectionBroadcast();
			FlyCamActive = false;
			_cutsceneSuppressUntil = Time.unscaledTime + 0.3f;
			if (_noiseAmplitude >= 0f)
			{
				CinemachineBasicMultiChannelPerlin componentInChildren2 = ((Component)me.flyCam).GetComponentInChildren<CinemachineBasicMultiChannelPerlin>();
				if ((Object)(object)componentInChildren2 != (Object)null)
				{
					componentInChildren2.m_AmplitudeGain = _noiseAmplitude;
				}
			}
		}

		private static IEnumerator ActivateEditorScanCo()
		{
			yield return null;
			GpuiPropScanner.ScanGpuiProps();
			yield return null;
			if (!_editorScanDone)
			{
				MaterialCatalog.InvalidateMaterialSources();
				_editorScanDone = true;
			}
		}

		private static void ToggleCursorMode()
		{
			CursorMode = !CursorMode;
			Cursor.lockState = (CursorLockMode)((!CursorMode) ? 1 : 2);
			Cursor.visible = CursorMode;
			if ((Object)(object)LevelEditorManager.Instance != (Object)null)
			{
				PhysicsObjectManager.SetEditorModeActive(CursorMode && FlyCamActive);
			}
			SetEditorPostProcessing(!CursorMode);
			if (!CursorMode)
			{
				LevelEditor.HideGizmo();
				LevelEditor.ClearRemoteSelectionBroadcast();
			}
		}

		private static void FreezePlayer(PlayerMovement player, bool frozen)
		{
			//IL_01df: 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_021f: 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_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			if (frozen)
			{
				if (!_freezeActive || !((Object)(object)_frozenPlayer == (Object)(object)player))
				{
					_frozenPlayer = player;
					_freezeActive = true;
					_movementWasEnabled = ((Behaviour)player).enabled;
					((Behaviour)player).enabled = false;
					_frozenController = ((Component)player).GetComponent<CharacterController>();
					if ((Object)(object)_frozenController != (Object)null)
					{
						_controllerWasEnabled = ((Collider)_frozenController).enabled;
						((Collider)_frozenController).enabled = false;
					}
					_frozenRigidbody = ((Component)player).GetComponent<Rigidbody>();
					if ((Object)(object)_frozenRigidbody != (Object)null)
					{
						_rigidbodyWasKinematic = _frozenRigidbody.isKinematic;
						_rigidbodyWasUseGravity = _frozenRigidbody.useGravity;
						_rigidbodyConstraints = _frozenRigidbody.constraints;
						_rigidbodyVelocity = _frozenRigidbody.velocity;
						_rigidbodyAngularVelocity = _frozenRigidbody.angularVelocity;
						_frozenRigidbody.velocity = Vector3.zero;
						_frozenRigidbody.angularVelocity = Vector3.zero;
						_frozenRigidbody.isKinematic = true;
						_frozenRigidbody.useGravity = false;
						_frozenRigidbody.constraints = (RigidbodyConstraints)126;
					}
					_frozenAnimator = player.anim;
					if ((Object)(object)_frozenAnimator != (Object)null)
					{
						_animatorSpeed = _frozenAnimator.speed;
						_frozenAnimator.speed = 0f;
					}
					Physics.SyncTransforms();
				}
			}
			else if (_freezeActive && !((Object)(object)_frozenPlayer != (Object)(object)player))
			{
				if ((Object)(object)_frozenAnimator != (Object)null)
				{
					_frozenAnimator.speed = _animatorSpeed;
				}
				if ((Object)(object)_frozenRigidbody != (Object)null)
				{
					_frozenRigidbody.constraints = _rigidbodyConstraints;
					_frozenRigidbody.isKinematic = _rigidbodyWasKinematic;
					_frozenRigidbody.useGravity = _rigidbodyWasUseGravity;
					_frozenRigidbody.velocity = _rigidbodyVelocity;
					_frozenRigidbody.angularVelocity = _rigidbodyAngularVelocity;
				}
				if ((Object)(object)_frozenController != (Object)null)
				{
					((Collider)_frozenController).enabled = _controllerWasEnabled;
				}
				((Behaviour)player).enabled = _movementWasEnabled;
				_freezeActive = false;
				_frozenPlayer = null;
				_frozenController = null;
				_frozenRigidbody = null;
				_frozenAnimator = null;
			}
		}

		public static void HandleFarTeleport()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0083: Unknown result type (might be due to invalid IL or missing references)
			if (Menu.me.teleporting || _farTeleportActive)
			{
				return;
			}
			PlayerMovement me = PlayerMovement.me;
			if (!((Object)(object)me == (Object)null))
			{
				Ray val = Camera.main.ScreenPointToRay(new Vector3((float)Screen.width / 2f, (float)Screen.height / 2f));
				RaycastHit val2 = default(RaycastHit);
				if (Physics.Raycast(val, ref val2, 1000f, LayerMask.op_Implicit(LayerCache.PropTerrainMask)))
				{
					_farTeleportActive = true;
					MelonCoroutines.Start(FlyCamTeleportCo(me, ((RaycastHit)(ref val2)).point));
				}
			}
		}

		private static IEnumerator FlyCamTeleportCo(PlayerMovement player, Vector3 target)
		{
			//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)
			BestRegionLoader brl = BestRegionLoader.me;
			if (!BaseMapController.BaseMapEnabled && (Object)(object)brl != (Object)null && brl.off)
			{
				brl.off = false;
			}
			FreezePlayer(player, frozen: false);
			float facingY = ((Component)player.flyCam).transform.eulerAngles.y;
			((Component)player.anim).transform.rotation = Quaternion.Euler(0f, facingY, 0f);
			player.pm.SwitchToActiveMode();
			player.pm.SwitchModes();
			((Component)player).gameObject.SetActive(false);
			GameObject crestWater = null;
			if (!BaseMapController.BaseMapEnabled)
			{
				GameObject bigManager = GameObject.Find("BigManagerPrefab");
				object obj;
				if (bigManager == null)
				{
					obj = null;
				}
				else
				{
					Transform obj2 = bigManager.transform.Find("CrestWaterRenderer");
					obj = ((obj2 != null) ? ((Component)obj2).gameObject : null);
				}
				crestWater = (GameObject)obj;
				if ((Object)(object)crestWater != (Object)null && !crestWater.activeSelf)
				{
					crestWater.SetActive(true);
				}
				else
				{
					crestWater = null;
				}
			}
			if ((Object)(object)brl != (Object)null && brl.chunkPositions != null && !brl.off)
			{
				Transform anchor = TeleportLoadAnchor;
				anchor.position = target;
				brl.loadingTransform = anchor;
				Il2CppStructArray<Vector3> chunkPositions = brl.chunkPositions;
				Vector3[] prevPositions = (Vector3[])(object)new Vector3[((Il2CppArrayBase<Vector3>)(object)chunkPositions).Length];
				for (int i = 0; i < 64; i++)
				{
					for (int j = 0; j < ((Il2CppArrayBase<Vector3>)(object)chunkPositions).Length; j++)
					{
						prevPositions[j] = ((Il2CppArrayBase<Vector3>)(object)chunkPositions)[j];
					}
					brl.Update();
					bool changed = false;
					for (int k = 0; k < ((Il2CppArrayBase<Vector3>)(object)chunkPositions).Length; k++)
					{
						if (((Il2CppArrayBase<Vector3>)(object)chunkPositions)[k] != prevPositions[k])
						{
							changed = true;
							break;
						}
					}
					if (!changed)
					{
						break;
					}
				}
			}
			SaveGod.me.stopSaving = true;
			SaveGod.theSave.continuePt = target;
			Menu.me.Teleport(target, false);
			float waitStart = Time.unscaledTime;
			bool slWasTrue = false;
			float slStuckSince = 0f;
			bool targetLoaded = false;
			while (Menu.me.teleporting)
			{
				float elapsed = Time.unscaledTime - waitStart;
				if (BestRegionLoader.somebodyLoading)
				{
					if (!slWasTrue)
					{
						slWasTrue = true;
						slStuckSince = Time.unscaledTime;
					}
					else if (Time.unscaledTime - slStuckSince > 5f)
					{
						BestRegionLoader.somebodyLoading = false;
						slWasTrue = false;
					}
				}
				else
				{
					slWasTrue = false;
				}
				if (!targetLoaded && elapsed >= 1f)
				{
					Vector3 origin = new Vector3(target.x, target.y + 100f, target.z);
					if (Physics.Raycast(origin, Vector3.down, 300f, LayerMask.op_Implicit(LayerCache.PropTerrainMask)))
					{
						targetLoaded = true;
					}
				}
				if (targetLoaded || elapsed > 60f)
				{
					if (elapsed > 60f && !targetLoaded)
					{
						MelonLogger.Warning("[FarTeleport] 60s with no terrain hit — forcing anyway");
					}
					BestRegionLoader.fullyLoaded = true;
				}
				yield return null;
			}
			if ((Object)(object)crestWater != (Object)null && !BaseMapController.BaseMapEnabled)
			{
				crestWater.SetActive(false);
			}
			SaveGod.me.stopSaving = false;
			if ((Object)(object)brl != (Object)null)
			{
				brl.loadingTransform = ((Component)player.flyCam).transform;
			}
			FreezePlayer(player, frozen: true);
			if (((Component)player).gameObject.activeInHierarchy && player.torsoRbs != null && ((Il2CppArrayBase<Rigidbody>)(object)player.torsoRbs).Length > 0)
			{
				float playerY = ((Component)((Il2CppArrayBase<Rigidbody>)(object)player.torsoRbs)[0]).transform.position.y;
				Vector3 camPos = ((Component)player.flyCam).transform.position;
				Vector3 camToTarget = target - camPos;
				float camDist = ((Vector3)(ref camToTarget)).magnitude;
				RaycastHit verifyHit = default(RaycastHit);
				if (camDist > 0.1f && Physics.Raycast(camPos, camToTarget / camDist, ref verifyHit, camDist + 100f, LayerMask.op_Implicit(LayerCache.PropTerrainMask)))
				{
					float delta = Mathf.Abs(playerY - ((RaycastHit)(ref verifyHit)).point.y);
					if (delta > 3f)
					{
						Vector3 corrected = ((RaycastHit)(ref verifyHit)).point;
						FreezePlayer(player, frozen: false);
						((Component)player).gameObject.SetActive(false);
						if (!BaseMapController.BaseMapEnabled && (Object)(object)crestWater != (Object)null)
						{
							crestWater.SetActive(true);
						}
						SaveGod.theSave.continuePt = corrected;
						Menu.me.Teleport(corrected, false);
						float corrStart = Time.unscaledTime;
						while (Menu.me.teleporting)
						{
							BestRegionLoader.fullyLoaded = true;
							if (Time.unscaledTime - corrStart > 10f)
							{
								MelonLogger.Warning("[FarTeleport] Correction teleport stuck 10s — forcing");
								BestRegionLoader.fullyLoaded = true;
							}
							yield return null;
						}
						if (!BaseMapController.BaseMapEnabled && (Object)(object)crestWater != (Object)null)
						{
							crestWater.SetActive(false);
						}
						if ((Object)(object)brl != (Object)null)
						{
							brl.loadingTransform = ((Component)player.flyCam).transform;
						}
						FreezePlayer(player, frozen: true);
					}
				}
			}
			MaterialVariantTracker.InvalidateMaterialCache();
			MaterialCatalog.EnsureMaterialListLoaded();
			MaterialCatalog.ReapplyAllMaterialOverrides();
			if (!BaseMapController.BaseMapEnabled)
			{
				BaseMapController.SetEditorPropsSnowDisabled(disable: true);
			}
			_farTeleportActive = false;
		}
	}
	internal static class GhostCubeConfig
	{
		private static Material _frameMaterial;

		public static void Configure(GameObject go)
		{
			//IL_0072: 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)go == (Object)null)
			{
				return;
			}
			foreach (MeshRenderer componentsInChild in go.GetComponentsInChildren<MeshRenderer>(true))
			{
				((Renderer)componentsInChild).forceRenderingOff = true;
				((Renderer)componentsInChild).enabled = false;
			}
			BuildFrame(go);
			BoxCollider val = go.GetComponent<BoxCollider>();
			if ((Object)(object)val == (Object)null)
			{
				val = go.AddComponent<BoxCollider>();
			}
			val.center = Vector3.zero;
			val.size = Vector3.one;
			((Collider)val).isTrigger = true;
			if ((Object)(object)go.GetComponent<GhostCollisionCutter>() == (Object)null)
			{
				go.AddComponent<GhostCollisionCutter>();
			}
		}

		internal static void BuildFrame(GameObject root)
		{
			//IL_0043: 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_0077: 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_00ab: 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_00df: 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_0113: 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_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: 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_01af: 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_01e3: 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_0218: 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)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: 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_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Expected O, but got Unknown
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Expected O, but got Unknown
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Material frameMaterial = GetFrameMaterial();
			if (!((Object)(object)frameMaterial == (Object)null))
			{
				(Vector3, Vector3)[] array = new(Vector3, Vector3)[12]
				{
					(new Vector3(-0.5f, -0.5f, -0.5f), new Vector3(0.5f, -0.5f, -0.5f)),
					(new Vector3(0.5f, -0.5f, -0.5f), new Vector3(0.5f, -0.5f, 0.5f)),
					(new Vector3(0.5f, -0.5f, 0.5f), new Vector3(-0.5f, -0.5f, 0.5f)),
					(new Vector3(-0.5f, -0.5f, 0.5f), new Vector3(-0.5f, -0.5f, -0.5f)),
					(new Vector3(-0.5f, 0.5f, -0.5f), new Vector3(0.5f, 0.5f, -0.5f)),
					(new Vector3(0.5f, 0.5f, -0.5f), new Vector3(0.5f, 0.5f, 0.5f)),
					(new Vector3(0.5f, 0.5f, 0.5f), new Vector3(-0.5f, 0.5f, 0.5f)),
					(new Vector3(-0.5f, 0.5f, 0.5f), new Vector3(-0.5f, 0.5f, -0.5f)),
					(new Vector3(-0.5f, -0.5f, -0.5f), new Vector3(-0.5f, 0.5f, -0.5f)),
					(new Vector3(0.5f, -0.5f, -0.5f), new Vector3(0.5f, 0.5f, -0.5f)),
					(new Vector3(0.5f, -0.5f, 0.5f), new Vector3(0.5f, 0.5f, 0.5f)),
					(new Vector3(-0.5f, -0.5f, 0.5f), new Vector3(-0.5f, 0.5f, 0.5f))
				};
				Transform val = root.transform.Find("GhostFrame");
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
				GameObject val2 = new GameObject("GhostFrame");
				val2.transform.SetParent(root.transform, false);
				val2.layer = root.layer;
				for (int i = 0; i < array.Length; i++)
				{
					GameObject val3 = new GameObject($"Edge_{i}");
					val3.transform.SetParent(val2.transform, false);
					val3.layer = root.layer;
					LineRenderer val4 = val3.AddComponent<LineRenderer>();
					val4.useWorldSpace = false;
					val4.positionCount = 2;
					val4.SetPosition(0, array[i].Item1);
					val4.SetPosition(1, array[i].Item2);
					val4.startWidth = 0.01f;
					val4.endWidth = 0.01f;
					val4.numCapVertices = 0;
					val4.numCornerVertices = 0;
					val4.alignment = (LineAlignment)0;
					((Renderer)val4).material = frameMaterial;
					val4.startColor = new Color(1f, 0.95f, 0.3f, 0.9f);
					val4.endColor = new Color(1f, 0.95f, 0.3f, 0.9f);
				}
			}
		}

		private static Material GetFrameMaterial()
		{
			//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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			if ((Object)(object)_frameMaterial != (Object)null)
			{
				return _frameMaterial;
			}
			Shader val = Shader.Find("Sprites/Default") ?? Shader.Find("Unlit/Color") ?? Shader.Find("Standard");
			_frameMaterial = new Material(val)
			{
				name = "BabyBlocks_GhostFrame",
				renderQueue = 5000
			};
			return _frameMaterial;
		}
	}
	public class GhostCollisionCutter : MonoBehaviour
	{
		private struct CarvedTerrainState
		{
			public TerrainData originalData;

			public Array originalHoles;

			public int xBase;

			public int yBase;

			public int width;

			public int height;

			public string carveKey;

			public bool IsValid => (Object)(object)originalData != (Object)null && originalHoles != null;
		}

		private static readonly Dictionary<Terrain, CarvedTerrainState> _carvedTerrains = new Dictionary<Terrain, CarvedTerrainState>();

		private static readonly List<GhostCollisionCutter> _instances = new List<GhostCollisionCutter>();

		private BoxCollider _volume;

		private const float PositionTolerance = 0.01f;

		private const float AngleTolerance = 0.05f;

		private bool _hasLastCarvePose;

		private Vector3 _lastCenter;

		private Vector3 _lastHalfExtents;

		private Quaternion _lastRotation;

		private string _lastCarveKey;

		private Transform _frameRoot;

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

		private void Awake()
		{
			_volume = ((Component)this).GetComponent<BoxCollider>();
			if ((Object)(object)_volume != (Object)null)
			{
				((Collider)_volume).isTrigger = true;
			}
			_frameRoot = ((Component)this).transform.Find("GhostFrame");
		}

		private void OnEnable()
		{
			_instances.Add(this);
			Refresh();
		}

		private void FixedUpdate()
		{
			Refresh();
		}

		private void Update()
		{
			UpdateFrameVisibility();
		}

		private void OnDisable()
		{
			_instances.Remove(this);
			ReleaseAll();
		}

		private void OnDestroy()
		{
			_instances.Remove(this);
			ReleaseAll();
		}

		private void UpdateFrameVisibility()
		{
			if ((Object)(object)_frameRoot == (Object)null)
			{
				_frameRoot = ((Component)this).transform.Find("GhostFrame");
			}
			if (!((Object)(object)_frameRoot == (Object)null))
			{
				bool flag = FlyCamController.FlyCamActive && FlyCamController.CursorMode;
				if (((Component)_frameRoot).gameObject.activeSelf != flag)
				{
					((Component)_frameRoot).gameObject.SetActive(flag);
				}
			}
		}

		private void Refresh()
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_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_0097: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00c7: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_volume == (Object)null)
			{
				_volume = ((Component)this).GetComponent<BoxCollider>();
			}
			if (!((Object)(object)_volume == (Object)null) && ((Component)this).gameObject.activeInHierarchy)
			{
				Vector3 lossyScale = ((Component)this).transform.lossyScale;
				Vector3 val = ((Component)this).transform.TransformPoint(_volume.center);
				Vector3 val2 = Vector3.Scale(_volume.size * 0.5f, new Vector3(Mathf.Abs(lossyScale.x), Mathf.Abs(lossyScale.y), Mathf.Abs(lossyScale.z)));
				Quaternion rotation = ((Component)this).transform.rotation;
				string debouncedCarveKey = GetDebouncedCarveKey(val, val2, rotation);
				RefreshTerrains(debouncedCarveKey, val, rotation, val2);
			}
		}

		private void RefreshTerrains(string carveKey, Vector3 cutterCenter, Quaternion cutterRotation, Vector3 cutterHalfExtents)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			Il2CppReferenceArray<Terrain> activeTerrains = Terrain.activeTerrains;
			if (activeTerrains == null)
			{
				return;
			}
			HashSet<Terrain> hashSet = new HashSet<Terrain>();
			for (int i = 0; i < ((Il2CppArrayBase<Terrain>)(object)activeTerrains).Length; i++)
			{
				Terrain val = ((Il2CppArrayBase<Terrain>)(object)activeTerrains)[i];
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.terrainData == (Object)null) && CutterOverlapsTerrainBounds(val, cutterCenter, cutterRotation, cutterHalfExtents))
				{
					hashSet.Add(val);
					ApplyTerrainCarve(val, carveKey, cutterCenter, cutterRotation, cutterHalfExtents);
				}
			}
			if (_carvedTerrains.Count == 0)
			{
				return;
			}
			List<Terrain> list = new List<Terrain>();
			foreach (KeyValuePair<Terrain, CarvedTerrainState> carvedTerrain in _carvedTerrains)
			{
				if (!hashSet.Contains(carvedTerrain.Key))
				{
					list.Add(carvedTerrain.Key);
				}
			}
			foreach (Terrain item in list)
			{
				RestoreTerrain(item);
			}
		}

		private static bool CutterOverlapsTerrainBounds(Terrain terrain, Vector3 cutterCenter, Quaternion cutterRotation, Vector3 cutterHalfExtents)
		{
			//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_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_0035: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_0072: 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_017c: 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)
			Transform transform = ((Component)terrain).transform;
			Vector3 size = terrain.terrainData.size;
			Vector3[] array = (Vector3[])(object)new Vector3[8];
			int num = 0;
			Vector3 val = default(Vector3);
			for (int i = -1; i <= 1; i += 2)
			{
				for (int j = -1; j <= 1; j += 2)
				{
					for (int k = -1; k <= 1; k += 2)
					{
						((Vector3)(ref val))..ctor(cutterHalfExtents.x * (float)i, cutterHalfExtents.y * (float)j, cutterHalfExtents.z * (float)k);
						Vector3 val2 = cutterCenter + cutterRotation * val;
						array[num++] = transform.InverseTransformPoint(val2);
					}
				}
			}
			float num2 = array[0].x;
			float num3 = array[0].x;
			float num4 = array[0].z;
			float num5 = array[0].z;
			for (int l = 1; l < array.Length; l++)
			{
				num2 = Mathf.Min(num2, array[l].x);
				num3 = Mathf.Max(num3, array[l].x);
				num4 = Mathf.Min(num4, array[l].z);
				num5 = Mathf.Max(num5, array[l].z);
			}
			return num3 >= 0f && num5 >= 0f && num2 <= size.x && num4 <= size.z;
		}

		private void ReleaseAll()
		{
			_hasLastCarvePose = false;
			if (_carvedTerrains.Count <= 0)
			{
				return;
			}
			List<Terrain> list = new List<Terrain>(_carvedTerrains.Keys);
			foreach (Terrain item in list)
			{
				RestoreTerrain(item);
			}
		}

		private void ApplyTerrainCarve(Terrain terrain, string carveKey, Vector3 cutterCenter, Quaternion cutterRotation, Vector3 cutterHalfExtents)
		{
			//IL_00f7: 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_00fa: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)terrain == (Object)null || (Object)(object)terrain.terrainData == (Object)null)
			{
				return;
			}
			TerrainData terrainData = terrain.terrainData;
			int holesResolution = terrainData.holesResolution;
			if (holesResolution <= 0)
			{
				return;
			}
			CarvedTerrainState value;
			bool flag = _carvedTerrains.TryGetValue(terrain, out value);
			bool flag2 = flag && IsSameNativeObject((Il2CppObjectBase)(object)value.originalData, (Il2CppObjectBase)(object)terrainData);
			if (!flag || !value.IsValid || !flag2)
			{
				value = new CarvedTerrainState
				{
					originalData = terrainData,
					originalHoles = terrainData.GetHoles(0, 0, holesResolution, holesResolution).Cast<Array>()
				};
			}
			if (!string.IsNullOrEmpty(value.carveKey) && string.Equals(value.carveKey, carveKey, StringComparison.Ordinal))
			{
				return;
			}
			if (!string.IsNullOrEmpty(value.carveKey))
			{
				RestoreTerrain(terrain, value);
			}
			if (!TryBuildTerrainHolePatch(terrain, terrainData, value.originalHoles, cutterCenter, cutterRotation, cutterHalfExtents, out var xBase, out var yBase, out var holes))
			{
				if (flag)
				{
					value.carveKey = null;
					value.xBase = (value.yBase = (value.width = (value.height = 0)));
					_carvedTerrains[terrain] = value;
				}
			}
			else
			{
				terrainData.SetHoles(xBase, yBase, (Il2CppObjectBase)(object)holes);
				value.xBase = xBase;
				value.yBase = yBase;
				value.width = holes.GetLength(1);
				value.height = holes.GetLength(0);
				value.carveKey = carveKey;
				_carvedTerrains[terrain] = value;
			}
		}

		private void RestoreTerrain(Terrain terrain)
		{
			if (!((Object)(object)terrain == (Object)null) && _carvedTerrains.TryGetValue(terrain, out var value) && value.IsValid)
			{
				RestoreTerrain(terrain, value);
				_carvedTerrains.Remove(terrain);
			}
		}

		private static void RestoreTerrain(Terrain terrain, CarvedTerrainState state)
		{
			if (!((Object)(object)terrain == (Object)null) && state.IsValid)
			{
				Array val = ExtractTerrainPatch(state.originalHoles, state.xBase, state.yBase, state.width, state.height);
				if (val != null)
				{
					state.originalData.SetHoles(state.xBase, state.yBase, (Il2CppObjectBase)(object)val);
				}
			}
		}

		private static bool TryBuildTerrainHolePatch(Terrain terrain, TerrainData data, Array originalHoles, Vector3 cutterCenter, Quaternion cutterRotation, Vector3 cutterHalfExtents, out int xBase, out int yBase, out Array holes)
		{
			//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_0068: 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_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_00a9: 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)
			//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_00b8: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: 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)
			//IL_0221: 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_0244: 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_0280: 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_01d9: 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_031a: 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_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_037c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0389: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_0397: 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_03a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
			xBase = 0;
			yBase = 0;
			holes = null;
			if ((Object)(object)terrain == (Object)null || (Object)(object)data == (Object)null || originalHoles == null)
			{
				return false;
			}
			int holesResolution = data.holesResolution;
			if (holesResolution <= 0)
			{
				return false;
			}
			Transform transform = ((Component)terrain).transform;
			Vector3 size = data.size;
			Vector3[] array = (Vector3[])(object)new Vector3[8];
			int num = 0;
			Vector3 val = default(Vector3);
			for (int i = -1; i <= 1; i += 2)
			{
				for (int j = -1; j <= 1; j += 2)
				{
					for (int k = -1; k <= 1; k += 2)
					{
						((Vector3)(ref val))..ctor(cutterHalfExtents.x * (float)i, cutterHalfExtents.y * (float)j, cutterHalfExtents.z * (float)k);
						Vector3 val2 = cutterCenter + cutterRotation * val;
						array[num++] = transform.InverseTransformPoint(val2);
					}
				}
			}
			float num2 = array[0].x;
			float num3 = array[0].x;
			float num4 = array[0].z;
			float num5 = array[0].z;
			for (int l = 1; l < array.Length; l++)
			{
				num2 = Mathf.Min(num2, array[l].x);
				num3 = Mathf.Max(num3, array[l].x);
				num4 = Mathf.Min(num4, array[l].z);
				num5 = Mathf.Max(num5, array[l].z);
			}
			if (num3 < 0f || num5 < 0f || num2 > size.x || num4 > size.z)
			{
				return false;
			}
			num2 = Mathf.Clamp(num2, 0f, size.x);
			num3 = Mathf.Clamp(num3, 0f, size.x);
			num4 = Mathf.Clamp(num4, 0f, size.z);
			num5 = Mathf.Clamp(num5, 0f, size.z);
			int num6 = Mathf.Clamp(Mathf.FloorToInt(num2 / size.x * (float)(holesResolution - 1)), 0, holesResolution - 1);
			int num7 = Mathf.Clamp(Mathf.CeilToInt(num3 / size.x * (float)(holesResolution - 1)), 0, holesResolution - 1);
			int num8 = Mathf.Clamp(Mathf.FloorToInt(num4 / size.z * (float)(holesResolution - 1)), 0, holesResolution - 1);
			int num9 = Mathf.Clamp(Mathf.CeilToInt(num5 / size.z * (float)(holesResolution - 1)), 0, holesResolution - 1);
			int num10 = num7 - num6 + 1;
			int num11 = num9 - num8 + 1;
			if (num10 <= 0 || num11 <= 0)
			{
				return false;
			}
			xBase = num6;
			yBase = num8;
			holes = Array.CreateInstance(Il2CppType.Of<bool>(), new Il2CppStructArray<long>(new long[2] { num11, num10 }));
			Quaternion val3 = Quaternion.Inverse(cutterRotation);
			int num12 = Mathf.Max(holesResolution - 1, 1);
			bool flag = false;
			Vector3 val4 = default(Vector3);
			for (int m = 0; m < num11; m++)
			{
				for (int n = 0; n < num10; n++)
				{
					int num13 = num6 + n;
					int num14 = num8 + m;
					float num15 = (float)num13 / (float)num12;
					float num16 = (float)num14 / (float)num12;
					float interpolatedHeight = data.GetInterpolatedHeight(num15, num16);
					((Vector3)(ref val4))..ctor(num15 * size.x, interpolatedHeight, num16 * size.z);
					Vector3 val5 = transform.TransformPoint(val4);
					Vector3 local = val3 * (val5 - cutterCenter);
					bool flag2 = PointInsideBox(local, cutterHalfExtents);
					if (flag2)
					{
						flag = true;
					}
					holes.SetValue(flag2 ? Object.op_Implicit(false) : originalHoles.GetValue(num14, num13), m, n);
				}
			}
			if (!flag)
			{
				holes = null;
				return false;
			}
			return true;
		}

		private static Array ExtractTerrainPatch(Array source, int xBase, int yBase, int width, int height)
		{
			if (source == null || width <= 0 || height <= 0)
			{
				return null;
			}
			Array val = Array.CreateInstance(Il2CppType.Of<bool>(), new Il2CppStructArray<long>(new long[2] { height, width }));
			for (int i = 0; i < height; i++)
			{
				for (int j = 0; j < width; j++)
				{
					val.SetValue(source.GetValue(yBase + i, xBase + j), i, j);
				}
			}
			return val;
		}

		private static bool IsSameNativeObject(Il2CppObjectBase a, Il2CppObjectBase b)
		{
			if (a == null || b == null)
			{
				return false;
			}
			return a.Pointer == b.Pointer;
		}

		private static string BuildCarveKey(Vector3 center, Vector3 half, Quaternion rot)
		{
			//IL_000d: 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_004d: 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_008d: 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_00cd: 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_010d: 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)
			return $"{center.x:F3},{center.y:F3},{center.z:F3}|{half.x:F3},{half.y:F3},{half.z:F3}|{rot.x:F3},{rot.y:F3},{rot.z:F3},{rot.w:F3}";
		}

		private string GetDebouncedCarveKey(Vector3 center, Vector3 halfExtents, Quaternion rotation)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (_hasLastCarvePose && Vector3.Distance(center, _lastCenter) <= 0.01f && Vector3.Distance(halfExtents, _lastHalfExtents) <= 0.01f && Quaternion.Angle(rotation, _lastRotation) <= 0.05f)
			{
				return _lastCarveKey;
			}
			string lastCarveKey = BuildCarveKey(center, halfExtents, rotation);
			_lastCenter = center;
			_lastHalfExtents = halfExtents;
			_lastRotation = rotation;
			_lastCarveKey = lastCarveKey;
			_hasLastCarvePose = true;
			return _lastCarveKey;
		}

		private static bool PointInsideBox(Vector3 local, Vector3 half)
		{
			//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_0013: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			return Mathf.Abs(local.x) <= half.x && Mathf.Abs(local.y) <= half.y && Mathf.Abs(local.z) <= half.z;
		}
	}
	internal static class SpawnPointConfig
	{
		private static Material _frameMaterial;

		private static readonly Color MarkerColor = new Color(0.3f, 1f, 0.45f, 0.9f);

		public static void Configure(GameObject go)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			foreach (MeshRenderer componentsInChild in go.GetComponentsInChildren<MeshRenderer>(true))
			{
				((Renderer)componentsInChild).forceRenderingOff = true;
				((Renderer)componentsInChild).enabled = false;
			}
			BuildMarker(go);
			BoxCollider val = go.GetComponent<BoxCollider>();
			if ((Object)(object)val == (Object)null)
			{
				val = go.AddComponent<BoxCollider>();
			}
			val.center = new Vector3(0f, 0.9f, 0f);
			val.size = new Vector3(0.8f, 1.8f, 0.8f);
			((Collider)val).isTrigger = true;
			if ((Object)(object)go.GetComponent<SpawnPointMarker>() == (Object)null)
			{
				go.AddComponent<SpawnPointMarker>();
			}
		}

		internal static void BuildMarker(GameObject root)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//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_0109: 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_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_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_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_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_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_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_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Material frameMaterial = GetFrameMaterial();
			if (!((Object)(object)frameMaterial == (Object)null))
			{
				Transform val = root.transform.Find("SpawnFrame");
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
				GameObject val2 = new GameObject("SpawnFrame");
				val2.transform.SetParent(root.transform, false);
				val2.layer = root.layer;
				Vector3[] array = (Vector3[])(object)new Vector3[24];
				for (int i = 0; i < 24; i++)
				{
					float num = (float)i / 24f * (float)Math.PI * 2f;
					array[i] = new Vector3(Mathf.Cos(num) * 0.4f, 0.02f, Mathf.Sin(num) * 0.4f);
				}
				AddLineLoop(val2, "Ring", array, frameMaterial, loop: true);
				AddLine(val2, "Pole", frameMaterial, new Vector3(0f, 0f, 0f), new Vector3(0f, 1.8f, 0f));
				Vector3 val3 = default(Vector3);
				((Vector3)(ref val3))..ctor(0f, 0.05f, 0.7f);
				AddLine(val2, "ArrowShaft", frameMaterial, new Vector3(0f, 0.05f, 0f), val3);
				AddLine(val2, "ArrowHeadL", frameMaterial, val3, val3 + Quaternion.Euler(0f, 150f, 0f) * Vector3.forward * 0.18f);
				AddLine(val2, "ArrowHeadR", frameMaterial, val3, val3 + Quaternion.Euler(0f, -150f, 0f) * Vector3.forward * 0.18f);
			}
		}

		private static void AddLine(GameObject parent, string name, Material mat, Vector3 a, Vector3 b)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0041: 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_008b: 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)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent.transform, false);
			val.layer = parent.layer;
			LineRenderer val2 = val.AddComponent<LineRenderer>();
			val2.useWorldSpace = false;
			val2.positionCount = 2;
			val2.SetPosition(0, a);
			val2.SetPosition(1, b);
			val2.startWidth = 0.015f;
			val2.endWidth = 0.015f;
			val2.numCapVertices = 0;
			val2.numCornerVertices = 0;
			val2.alignment = (LineAlignment)0;
			((Renderer)val2).material = mat;
			val2.startColor = MarkerColor;
			val2.endColor = MarkerColor;
		}

		private static void AddLineLoop(GameObject parent, string name, Vector3[] points, Material mat, bool loop)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0090: 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)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent.transform, false);
			val.layer = parent.layer;
			LineRenderer val2 = val.AddComponent<LineRenderer>();
			val2.useWorldSpace = false;
			val2.loop = loop;
			val2.positionCount = points.Length;
			val2.SetPositions(Il2CppStructArray<Vector3>.op_Implicit(points));
			val2.startWidth = 0.015f;
			val2.endWidth = 0.015f;
			val2.numCapVertices = 0;
			val2.numCornerVertices = 0;
			val2.alignment = (LineAlignment)0;
			((Renderer)val2).material = mat;
			val2.startColor = MarkerColor;
			val2.endColor = MarkerColor;
		}

		private static Material GetFrameMaterial()
		{
			//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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			if ((Object)(object)_frameMaterial != (Object)null)
			{
				return _frameMaterial;
			}
			Shader val = Shader.Find("Sprites/Default") ?? Shader.Find("Unlit/Color") ?? Shader.Find("Standard");
			_frameMaterial = new Material(val)
			{
				name = "BabyBlocks_SpawnFrame",
				renderQueue = 5000
			};
			return _frameMaterial;
		}
	}
	public class SpawnPointMarker : MonoBehaviour
	{
		private Transform _frameRoot;

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

		private void Awake()
		{
			_frameRoot = ((Component)this).transform.Find("SpawnFrame");
		}

		private void Update()
		{
			if ((Object)(object)_frameRoot == (Object)null)
			{
				_frameRoot = ((Component)this).transform.Find("SpawnFrame");
			}
			if (!((Object)(object)_frameRoot == (Object)null))
			{
				bool flag = FlyCamController.FlyCamActive && FlyCamController.CursorMode;
				if (((Component)_frameRoot).gameObject.activeSelf != flag)
				{
					((Component)_frameRoot).gameObject.SetActive(flag);
				}
			}
		}
	}
	internal static class GizmoRenderer
	{
		private struct MeshData
		{
			public Vector3[] verts;

			public int[] tris;

			public Vector3[] smoothNormals;
		}

		private struct OutlineShellData
		{
			public int meshId;

			public Vector3 position;

			public Quaternion rotation;

			public Vector3 scale;

			public float thickness;

			public Vector3[] worldVerts;

			public int[] tris;

			public Mesh mesh;
		}

		public const int Layer = 31;

		public static readonly int Mask = int.MinValue;

		public const int FreeRotateAxis = 7;

		public const float FreeRotSphereDrawScale = 0.85f;

		private const float RingOuterRadius = 0.65f;

		private const float RingInnerRadius = 0.5f;

		private const float RingPickPadding = 0.05f;

		public static readonly Quaternion[] PivotRots = (Quaternion[])(object)new Quaternion[3]
		{
			Quaternion.Euler(0f, 0f, -90f),
			Quaternion.identity,
			Quaternion.Euler(-90f, 0f, 0f)
		};

		private static readonly Quaternion[] RingPivotRots = (Quaternion[])(object)new Quaternion[3]
		{
			Quaternion.Euler(0f, 0f, -90f),
			Quaternion.identity,
			Quaternion.Euler(90f, 0f, 0f)
		};

		private static readonly Vector3 ShaftPos = new Vector3(0f, 0.25f, 0f);

		private static readonly Vector3 ShaftScale = new Vector3(0.05f, 0.25f, 0.05f);

		private static readonly Vector3 TipPos = new Vector3(0f, 0.5f, 0f);

		private static readonly Vector3 TipScale = new Vector3(0.14f, 0.2f, 0.14f);

		private static readonly Vector3 ScaleTipPos = new Vector3(0f, 0.55f, 0f);

		private static readonly Vector3 ScaleTipScale = new Vector3(0.16f, 0.16f, 0.16f);

		private static readonly float PlaneSizeMove = 0.2625f;

		private static readonly float PlaneSizeScale = 0.3f;

		private static readonly float PlaneThickness = 0.03f;

		private static Mesh _shaftMesh;

		private static Mesh _coneTipMesh;

		private static Mesh _cubeTipMesh;

		private static Mesh _sphereMesh;

		private static Mesh _ringMesh;

		private static Material[] _mats;

		private static Material[] _hoverMats;

		private static Material[] _planeMats;

		private static Material[] _planeHoverMats;

		private static Material _freeMat;

		private static Material _freeHoverMat;

		private static Material _freeRotMat;

		private static Material _freeRotHoverMat;

		private static Material[] _occMats;

		private static Material[] _planeOccMats;

		private static Material _freeOccMat;

		public static float OutlineThickness = 0.03f;

		public static float OutlineOccludedAlpha = 0.35f;

		public static float OutlineWidth = 2f;

		private static Material _stencilClearMat;

		private static Material _stencilMarkMat;

		private static Material _outlineMat;

		private static Material _outlineOccMat;

		private static CommandBuffer _outlineBuffer;

		private static Camera _outlineCameraTarget;

		private static CommandBuffer _gizmoZTestBuffer;

		private static Material _maskMat;

		private static Material _ppMat;

		private static Material _depthCaptureMat;

		private static RenderTexture _depthCopyRT;

		private static CommandBuffer _depthCaptureBuffer;

		private static Camera _depthCaptureCameraTarget;

		private static readonly int _maskRTId = Shader.PropertyToID("_BabyBlocks_SelectionMaskRT");

		private static readonly int _depthCopyTexId = Shader.PropertyToID("_BabyBlocksDepthCopy");

		private static CommandBuffer _ssBuffer;

		private static Camera _ssCameraTarget;

		private static IReadOnlyList<LevelEditorObject> _ssLastSelection;

		private static readonly List<(Color color, IReadOnlyList<LevelEditorObject> targets)> _ssRemoteHighlights = new List<(Color, IReadOnlyList<LevelEditorObject>)>();

		private static readonly List<MaterialPropertyBlock> _ssRemoteMpbPool = new List<MaterialPropertyBlock>();

		private static bool _outlineTranslateDrag;

		private static Vector3 _outlineTranslateDelta;

		private static readonly Dictionary<Mesh, MeshData> _meshDataCache = new Dictionary<Mesh, MeshData>();

		private static readonly Dictionary<int, OutlineShellData> _outlineShellCache = new Dictionary<int, OutlineShellData>();

		private static Mesh _combinedOutlineShell;

		private static int _combinedOutlineSignature;

		private static readonly List<CombineInstance> _combinedOutlineCombines = new List<CombineInstance>();

		private static readonly List<(Mesh mesh, Matrix4x4 matrix, int subMeshCount)> _outlineMarks = new List<(Mesh, Matrix4x4, int)>();

		private static readonly List<Mesh> _remoteOutlineShells = new List<Mesh>();

		private static readonly List<(Mesh mesh, Matrix4x4 matrix, int subMeshCount)> _remoteOutlineMarks = new List<(Mesh, Matrix4x4, int)>();

		private static GameObject _root;

		private static GameObject _arrowHandles;

		private static GameObject _ringHandles;

		private static Camera _overlayCam;

		private static Vector3 _pivotPos;

		private static bool _pivotOverrideActive;

		private static Vector3 _pivotOverride;

		private static readonly Quaternion FlipArrowQ = Quaternion.Euler(180f, 0f, 0f);

		private static Transform[] _axisPivots = (Transform[])(object)new Transform[3];

		private static Transform[] _planeHandles = (Transform[])(object)new Transform[3];

		private static bool[] _axisFlipped = new bool[3];

		private static GizmoHandle[] _ringHandleRefs = new GizmoHandle[3];

		private const float MaxPlausibleBoundsExtent = 100f;

		public static bool HasRemoteHighlights => _ssRemoteHighlights.Count > 0;

		public static bool ScreenSpaceShadersLoaded => (Object)(object)_maskMat != (Object)null && (Object)(object)_ppMat != (Object)null;

		public static bool IsReady => (Object)(object)_root != (Object)null && (Object)(object)_overlayCam != (Object)null;

		public static Vector3 PivotPosition => _pivotPos;

		public static bool StencilMaterialsReady => (Object)(object)_stencilClearMat != (Object)null && (Object)(object)_stencilMarkMat != (Object)null;

		public static void ClearRemoteHighlights()
		{
			_ssRemoteHighlights.Clear();
		}

		public static void AddRemoteHighlight(Color color, IReadOnlyList<LevelEditorObject> targets)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (targets != null && targets.Count > 0)
			{
				_ssRemoteHighlights.Add((color, targets));
			}
		}

		public static void SetTranslateDragDelta(Vector3 delta)
		{
			//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)
			_outlineTranslateDrag = true;
			_outlineTranslateDelta = delta;
		}

		public static void ClearDragDelta()
		{
			_outlineTranslateDrag = false;
		}

		public static Quaternion GetEffectivePivotRot(int i)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			return (i >= 0 && i < 3 && _axisFlipped[i]) ? (PivotRots[i] * FlipArrowQ) : PivotRots[i];
		}

		public static void SetPivotOverride(Vector3 pivot)
		{
			//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)
			_pivotOverrideActive = true;
			_pivotOverride = pivot;
		}

		public static void ClearPivotOverride()
		{
			_pivotOverrideActive = false;
		}

		public static void Init()
		{
			InitMeshes();
			InitMaterials();
			BuildColliders();
			_overlayCam = BuildCam(100f, 500000f, (CameraClearFlags)3);
			AttachGizmoZTestBuffer(_overlayCam);
			LoadScreenSpaceShaders();
		}

		public static void Sync(IReadOnlyList<LevelEditorObject> selection, LevelEditorObject primary, LevelEditor.ToolMode tool, Camera mainCam)
		{
			//IL_0080: 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_0085: 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_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_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_010f: 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_012b: 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_0156: 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_00e5: 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_01d5: 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_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: 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_0206: 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_022c: 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_0305: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: 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_035c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_root == (Object)null)
			{
				return;
			}
			bool flag = selection != null && selection.Count > 0;
			_root.SetActive(flag);
			if ((Object)(object)_overlayCam != (Object)null)
			{
				((Behaviour)_overlayCam).enabled = flag || _ssRemoteHighlights.Count > 0;
			}
			if (!flag)
			{
				return;
			}
			_pivotPos = (_pivotOverrideActive ? _pivotOverride : GetSelectionBoundsCenter(selection));
			_root.transform.position = _pivotPos;
			Quaternion rotation;
			if ((!LevelEditor.LocalMode && tool != LevelEditor.ToolMode.Scale) || !((Object)(object)primary != (Object)null))
			{
				rotation = Quaternion.identity;
			}
			else if (primary.groupId > 0)
			{
				GameObject groupRoot = GroupManager.GetGroupRoot(primary.groupId);
				rotation = ((groupRoot != null) ? groupRoot.transform.rotation : Quaternion.identity);
			}
			else
			{
				rotation = ((Component)primary).transform.rotation;
			}
			_root.transform.rotation = rotation;
			float num = Vector3.Distance(((Component)mainCam).transform.position, _root.transform.position);
			_root.transform.localScale = Vector3.one * Mathf.Max(num * 0.14f, 0.02f);
			bool flag2 = tool == LevelEditor.ToolMode.Rotate;
			if ((Object)(object)_arrowHandles != (Object)null)
			{
				_arrowHandles.SetActive(!flag2);
			}
			if ((Object)(object)_ringHandles != (Object)null)
			{
				_ringHandles.SetActive(flag2);
			}
			for (int i = 0; i < 3; i++)
			{
				if (!flag2 && (Object)(object)_axisPivots[i] != (Object)null)
				{
					Vector3 val = _root.transform.rotation * (PivotRots[i] * Vector3.up);
					_axisFlipped[i] = Vector3.Dot(val, ((Component)mainCam).transform.position - _pivotPos) < 0f;
					_axisPivots[i].localRotation = GetEffectivePivotRot(i);
					continue;
				}
				_axisFlipped[i] = false;
				if ((Object)(object)_axisPivots[i] != (Object)null)
				{
					_axisPivots[i].localRotation = PivotRots[i];
				}
			}
			for (int j = 0; j < 3; j++)
			{
				if (!((Object)(object)_planeHandles[j] == (Object)null))
				{
					int num2 = j switch
					{
						1 => 1, 
						0 => 0, 
						_ => 0, 
					};
					int num3 = j switch
					{
						1 => 2, 
						0 => 1, 
						_ => 2, 
					};
					float num4 = (_axisFlipped[num2] ? (-1f) : 1f);
					float num5 = (_axisFlipped[num3] ? (-1f) : 1f);
					Vector3 val2 = PivotRots[num2] * Vector3.up * num4;
					Vector3 val3 = PivotRots[num3] * Vector3.up * num5;
					_planeHandles[j].localPosition = (val2 + val3) * PlaneSizeMove * 0.5f;
				}
			}
			SyncCamToMain(_overlayCam, mainCam);
		}

		private static void SyncCamToMain(Camera cam, Camera mainCam)
		{
			//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)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)cam == (Object)null))
			{
				((Component)cam).transform.SetPositionAndRotation(((Component)mainCam).transform.position, ((Component)mainCam).transform.rotation);
				cam.fieldOfView = mainCam.fieldOfView;
				cam.aspect = mainCam.aspect;
				cam.nearClipPlane = mainCam.nearClipPlane;
				cam.rect = mainCam.rect;
			}
		}

		public static void EnsureCamera()
		{
			if ((Object)(object)_root != (Object)null && (Object)(object)_overlayCam == (Object)null)
			{
				_overlayCam = BuildCam(100f, 500000f, (CameraClearFlags)3);
				_gizmoZTestBuffer = null;
				AttachGizmoZTestBuffer(_overlayCam);
			}
		}

		private static void AttachGizmoZTestBuffer(Camera cam)
		{
			//IL_001b: Unknown result type (might be due to