using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using AmplifyOcclusion;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using RealPortal.Api;
using RealPortal.Engine;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Jobs;
using UnityEngine;
using UnityEngine.Experimental.Rendering;
using UnityEngine.LowLevel;
using UnityEngine.PlayerLoop;
using UnityEngine.PostProcessing;
using UnityEngine.Rendering;
using UnityStandardAssets.ImageEffects;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("RealPortalLab")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("RealPortal")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("RealPortal")]
[assembly: AssemblyTitle("RealPortal")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace RealPortal
{
	internal static class AreaRenderState
	{
		internal struct Values
		{
			public Quaternion LightRot;

			public float LightIntensity;

			public Color LightColor;

			public Color FogColor;

			public float FogDensity;

			public Color Ambient;

			public float CloudRain;

			public float CloudOpacity;

			public Vector4 SkyDir;

			public Vector4 SunDir;

			public Color SunFog;

			public Color SunCol;

			public Color AmbientGlobal;

			public float Wet;

			public float Aurora;

			public Vector4 Wind1;

			public Vector4 Wind2;

			public Vector4 WindForce;
		}

		private sealed class Snapshot
		{
			public EnvSetup Env;

			public float Wet;

			public Values V;
		}

		private static readonly int s_skyboxSunDir = Shader.PropertyToID("_SkyboxSunDir");

		private static readonly int s_sunDir = Shader.PropertyToID("_SunDir");

		private static readonly int s_sunFogColor = Shader.PropertyToID("_SunFogColor");

		private static readonly int s_sunColor = Shader.PropertyToID("_SunColor");

		private static readonly int s_ambientColor = Shader.PropertyToID("_AmbientColor");

		private static readonly int s_wet = Shader.PropertyToID("_Wet");

		private static readonly int s_aurora = Shader.PropertyToID("_AuroraStrength");

		private static readonly int s_rain = Shader.PropertyToID("_Rain");

		private static readonly int s_opacity = Shader.PropertyToID("_Opacity");

		private static readonly int s_wind1 = Shader.PropertyToID("_GlobalWind1");

		private static readonly int s_wind2 = Shader.PropertyToID("_GlobalWind2");

		private static readonly int s_windForce = Shader.PropertyToID("_GlobalWindForce");

		private static Values s_game;

		private static Values s_cur;

		private static Material s_clouds;

		private static bool s_open;

		private static int s_batch;

		internal static int LabWrites;

		internal static int LabSkipped;

		private static readonly List<Snapshot> s_snapshots = new List<Snapshot>();

		private static int s_count;

		private static int s_snapshotBatch = -1;

		internal static bool Open => s_open;

		internal static ref readonly Values Game => ref s_game;

		internal static void Begin(EnvMan em)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			Light dirLight = em.m_dirLight;
			s_game.LightRot = ((Component)dirLight).transform.rotation;
			s_game.LightIntensity = dirLight.intensity;
			s_game.LightColor = dirLight.color;
			s_game.FogColor = RenderSettings.fogColor;
			s_game.FogDensity = RenderSettings.fogDensity;
			s_game.Ambient = RenderSettings.ambientLight;
			s_clouds = (((Object)(object)em.m_clouds != (Object)null) ? ((Renderer)em.m_clouds).sharedMaterial : null);
			if ((Object)(object)s_clouds != (Object)null)
			{
				s_game.CloudRain = s_clouds.GetFloat(s_rain);
				s_game.CloudOpacity = s_clouds.GetFloat(s_opacity);
			}
			s_game.SkyDir = Shader.GetGlobalVector(s_skyboxSunDir);
			s_game.SunDir = Shader.GetGlobalVector(s_sunDir);
			s_game.SunFog = Shader.GetGlobalColor(s_sunFogColor);
			s_game.SunCol = Shader.GetGlobalColor(s_sunColor);
			s_game.AmbientGlobal = Shader.GetGlobalColor(s_ambientColor);
			s_game.Wet = Shader.GetGlobalFloat(s_wet);
			s_game.Aurora = Shader.GetGlobalFloat(s_aurora);
			s_game.Wind1 = Shader.GetGlobalVector(s_wind1);
			s_game.Wind2 = Shader.GetGlobalVector(s_wind2);
			s_game.WindForce = Shader.GetGlobalVector(s_windForce);
			s_cur = s_game;
			s_open = true;
			s_batch++;
		}

		internal static void Apply(EnvMan em, in Values to)
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: 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_00fa: 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_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: 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_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			if (!s_open)
			{
				return;
			}
			int num = 0;
			Light val = (((Object)(object)em != (Object)null) ? em.m_dirLight : null);
			if ((Object)(object)val != (Object)null)
			{
				if (!Eq(s_cur.LightRot, to.LightRot))
				{
					((Component)val).transform.rotation = to.LightRot;
					num++;
				}
				if (s_cur.LightIntensity != to.LightIntensity)
				{
					val.intensity = to.LightIntensity;
					num++;
				}
				if (!Eq(s_cur.LightColor, to.LightColor))
				{
					val.color = to.LightColor;
					num++;
				}
			}
			if (!Eq(s_cur.FogColor, to.FogColor))
			{
				RenderSettings.fogColor = to.FogColor;
				num++;
			}
			if (s_cur.FogDensity != to.FogDensity)
			{
				RenderSettings.fogDensity = to.FogDensity;
				num++;
			}
			if (!Eq(s_cur.Ambient, to.Ambient))
			{
				RenderSettings.ambientLight = to.Ambient;
				num++;
			}
			if ((Object)(object)s_clouds != (Object)null)
			{
				if (s_cur.CloudRain != to.CloudRain)
				{
					s_clouds.SetFloat(s_rain, to.CloudRain);
					num++;
				}
				if (s_cur.CloudOpacity != to.CloudOpacity)
				{
					s_clouds.SetFloat(s_opacity, to.CloudOpacity);
					num++;
				}
			}
			if (!Eq(s_cur.SkyDir, to.SkyDir))
			{
				Shader.SetGlobalVector(s_skyboxSunDir, to.SkyDir);
				num++;
			}
			if (!Eq(s_cur.SunDir, to.SunDir))
			{
				Shader.SetGlobalVector(s_sunDir, to.SunDir);
				num++;
			}
			if (!Eq(s_cur.SunFog, to.SunFog))
			{
				Shader.SetGlobalColor(s_sunFogColor, to.SunFog);
				num++;
			}
			if (!Eq(s_cur.SunCol, to.SunCol))
			{
				Shader.SetGlobalColor(s_sunColor, to.SunCol);
				num++;
			}
			if (!Eq(s_cur.AmbientGlobal, to.AmbientGlobal))
			{
				Shader.SetGlobalColor(s_ambientColor, to.AmbientGlobal);
				num++;
			}
			if (s_cur.Wet != to.Wet)
			{
				Shader.SetGlobalFloat(s_wet, to.Wet);
				num++;
			}
			if (s_cur.Aurora != to.Aurora)
			{
				Shader.SetGlobalFloat(s_aurora, to.Aurora);
				num++;
			}
			if (!Eq(s_cur.Wind1, to.Wind1))
			{
				Shader.SetGlobalVector(s_wind1, to.Wind1);
				num++;
			}
			if (!Eq(s_cur.Wind2, to.Wind2))
			{
				Shader.SetGlobalVector(s_wind2, to.Wind2);
				num++;
			}
			if (!Eq(s_cur.WindForce, to.WindForce))
			{
				Shader.SetGlobalVector(s_windForce, to.WindForce);
				num++;
			}
			s_cur = to;
			LabWrites += num;
			if (num == 0)
			{
				LabSkipped++;
			}
		}

		internal static void ToGame(EnvMan em)
		{
			if (s_open)
			{
				Apply(em, in s_game);
			}
		}

		internal static void End(EnvMan em)
		{
			if (s_open)
			{
				if ((Object)(object)em != (Object)null)
				{
					Apply(em, in s_game);
				}
				s_open = false;
				s_clouds = null;
			}
		}

		internal static bool Find(EnvSetup env, float wet, out Values v)
		{
			if (s_snapshotBatch == s_batch)
			{
				for (int i = 0; i < s_count; i++)
				{
					Snapshot snapshot = s_snapshots[i];
					if (snapshot.Env == env && snapshot.Wet == wet)
					{
						v = snapshot.V;
						return true;
					}
				}
			}
			v = default(Values);
			return false;
		}

		internal static void Keep(EnvSetup env, float wet, in Values v)
		{
			if (s_snapshotBatch != s_batch)
			{
				s_snapshotBatch = s_batch;
				s_count = 0;
			}
			if (s_count == s_snapshots.Count)
			{
				s_snapshots.Add(new Snapshot());
			}
			Snapshot snapshot = s_snapshots[s_count++];
			snapshot.Env = env;
			snapshot.Wet = wet;
			snapshot.V = v;
		}

		private static bool Eq(Quaternion a, Quaternion b)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (a.x == b.x && a.y == b.y && a.z == b.z)
			{
				return a.w == b.w;
			}
			return false;
		}

		private static bool Eq(Color a, Color b)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (a.r == b.r && a.g == b.g && a.b == b.b)
			{
				return a.a == b.a;
			}
			return false;
		}

		private static bool Eq(Vector4 a, Vector4 b)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (a.x == b.x && a.y == b.y && a.z == b.z)
			{
				return a.w == b.w;
			}
			return false;
		}

		internal static void Clear()
		{
			s_snapshots.Clear();
			s_count = 0;
			s_snapshotBatch = -1;
		}
	}
	internal static class BaseView
	{
		private sealed class Zone
		{
			public Vector2s Id;

			public int Index;

			public int Mark;

			public float MinY;

			public float MaxY;

			public bool HasGround;

			public readonly List<Renderer> Ground = new List<Renderer>();

			public List<Item> Items = new List<Item>();

			public List<Item> Next = new List<Item>();

			public readonly List<ZDO> Snapshot = new List<ZDO>();

			public int Cursor = -1;

			public int ListedVersion = int.MinValue;

			public float ListedAt = float.NegativeInfinity;

			public bool Near;

			public bool Ring;

			public bool InView;

			public bool Close;

			public float Distance;

			public void Reset(Vector2s id, int index)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				Id = id;
				Index = index;
				HasGround = false;
				Cursor = -1;
				ListedVersion = int.MinValue;
				ListedAt = float.NegativeInfinity;
			}

			public void Clear()
			{
				Ground.Clear();
				Items.Clear();
				Next.Clear();
				Snapshot.Clear();
				Cursor = -1;
			}
		}

		private struct Item
		{
			public Parts Parts;

			public bool Distant;
		}

		private sealed class Parts
		{
			public ZNetView View;

			public Transform Root;

			public Renderer[] Renderers;

			public sbyte[] Level;

			public short[] Group;

			public Vector3[] GroupAt;

			public float[] GroupSize;

			public float[][] Heights;

			public bool Mover;

			public float ListedAt;
		}

		private struct Lively
		{
			public ParticleSystemRenderer[] Renderers;

			public Transform Root;

			public int Index;

			public bool Distant;
		}

		private struct LightEntry
		{
			public Light Light;

			public int Index;

			public bool Distant;
		}

		internal static int LabBaseHidden;

		internal static int LabZones;

		internal static int LabZonesInView;

		internal static long LabListed;

		private const int ZoneSpan = 512;

		private const float ZoneMargin = 16f;

		private const float AboveGround = 96f;

		private const float BelowGround = 32f;

		private const int ListAtLeast = 8;

		private const int ClutterPerFrame = 256;

		private const double ListBudgetMs = 0.25;

		private const float ZoneRelist = 2f;

		private const float ViewRelist = 10f;

		private const float LodMargin = 0.75f;

		private const int Culled = -100;

		internal static readonly HashSet<Transform> Crossing = new HashSet<Transform>();

		private static int[] s_zoneOf;

		private static readonly List<Zone> s_zones = new List<Zone>();

		private static readonly Stack<Zone> s_pool = new Stack<Zone>();

		private static readonly HashSet<Vector2s> s_set = new HashSet<Vector2s>();

		private static int s_mark;

		private static int s_version = int.MinValue;

		private static int s_near = -1;

		private static int s_total = -1;

		private static bool s_classic;

		private static Vector2s s_me;

		private static float s_zonesAt;

		private static float s_listsAt;

		private static float s_sweepAt;

		private static float s_errorAt;

		private static readonly List<LightEntry> s_lights = new List<LightEntry>();

		private static readonly List<Lively> s_lively = new List<Lively>();

		private static List<Renderer> s_clutter = new List<Renderer>();

		private static List<Renderer> s_clutterNext = new List<Renderer>();

		private static int s_clutterCursor;

		private static Vector3 s_clutterFrom;

		private static bool s_clutterHas;

		private static readonly Dictionary<ZNetView, Parts> s_parts = new Dictionary<ZNetView, Parts>();

		private static readonly Dictionary<ZNetView, ParticleSystemRenderer[]> s_particlesOf = new Dictionary<ZNetView, ParticleSystemRenderer[]>();

		private static readonly Dictionary<LightLod, bool> s_lightDistant = new Dictionary<LightLod, bool>();

		private static readonly List<Renderer> s_hidden = new List<Renderer>();

		private static readonly List<Light> s_off = new List<Light>();

		private static readonly Plane[] s_planes = (Plane[])(object)new Plane[6];

		private static int[] s_level = new int[16];

		private static readonly List<Renderer> s_renderers = new List<Renderer>();

		private static readonly List<LODGroup> s_groups = new List<LODGroup>();

		private static readonly List<ParticleSystemRenderer> s_particles = new List<ParticleSystemRenderer>();

		private static readonly List<ZNetView> s_views = new List<ZNetView>();

		private static readonly List<Vector3> s_points = new List<Vector3>();

		private static readonly Dictionary<Renderer, int> s_lodOf = new Dictionary<Renderer, int>();

		private static readonly List<ZNetView> s_gone = new List<ZNetView>();

		private static readonly ParticleSystemRenderer[] s_noParticles = (ParticleSystemRenderer[])(object)new ParticleSystemRenderer[0];

		private static readonly Stopwatch s_watch = new Stopwatch();

		private static readonly FieldRef<ZDOMan, List<ZDO>[]> s_objectsBySector = AccessTools.FieldRefAccess<ZDOMan, List<ZDO>[]>("m_objectsBySector");

		private static readonly FieldRef<Heightmap, MeshRenderer> s_heightmapRenderer = AccessTools.FieldRefAccess<Heightmap, MeshRenderer>("m_meshRenderer");

		private static readonly FieldRef<HashSet<LightLod>> s_lodLights = AccessTools.StaticFieldRefAccess<HashSet<LightLod>>(AccessTools.Field(typeof(LightLod), "m_lights"));

		private static readonly FieldRef<LightLod, Light> s_lodLight = AccessTools.FieldRefAccess<LightLod, Light>("m_light");

		private static readonly FieldRef<ClutterSystem, GameObject> s_grassRoot = AccessTools.FieldRefAccess<ClutterSystem, GameObject>("m_grassRoot");

		private static readonly FieldRef<SmokeRenderer, Dictionary<Vector3Int, List<Smoke>>> s_smokeChunks = AccessTools.FieldRefAccess<SmokeRenderer, Dictionary<Vector3Int, List<Smoke>>>("m_chunkedSmoke");

		private static readonly FieldRef<SmokeRenderer, Dictionary<Vector3Int, ParticleSystem>> s_smokeSystems = AccessTools.FieldRefAccess<SmokeRenderer, Dictionary<Vector3Int, ParticleSystem>>("m_chunkedParticleSystems");

		internal static void Hide(PortalSystem sys, Camera cam, bool through)
		{
			if (s_hidden.Count > 0 || s_off.Count > 0)
			{
				Show();
			}
			LabBaseHidden = 0;
			if (!WindowFlags.BaseHidesFar || (Object)(object)sys == (Object)null || (Object)(object)cam == (Object)null || Plugin.Enabled == null || !Plugin.Enabled.Value || (Object)(object)ZNet.instance == (Object)null || (Object)(object)ZoneSystem.instance == (Object)null || ZDOMan.instance == null || (Object)(object)ZNetScene.instance == (Object)null || GameCamera.InFreeFly() || (sys.Areas.Count == 0 && s_zones.Count == 0))
			{
				if (s_zones.Count > 0 || s_clutter.Count > 0)
				{
					Forget();
				}
			}
			else
			{
				if (through)
				{
					return;
				}
				try
				{
					RemoteAreas areas = sys.Areas;
					float unscaledTime = Time.unscaledTime;
					Zones(areas, unscaledTime);
					if (unscaledTime >= s_listsAt)
					{
						s_listsAt = unscaledTime + 1f;
						ListGround();
						ListLights();
						ListLively(areas);
					}
					ListClutter();
					if (unscaledTime >= s_sweepAt)
					{
						s_sweepAt = unscaledTime + 10f;
						Sweep();
					}
					View(cam);
					ListObjects(areas.AreasVersion, unscaledTime);
					Apply(cam);
					LabBaseHidden = s_hidden.Count + s_off.Count;
				}
				catch (Exception ex)
				{
					Show();
					if (Time.unscaledTime >= s_errorAt)
					{
						s_errorAt = Time.unscaledTime + 10f;
						Plugin.Log.LogWarning((object)("Win.BaseHidesFar: hiding the far areas from the game camera failed: " + ex));
					}
				}
			}
		}

		internal static void Show()
		{
			for (int i = 0; i < s_hidden.Count; i++)
			{
				Renderer val = s_hidden[i];
				if ((Object)(object)val != (Object)null)
				{
					val.forceRenderingOff = false;
				}
			}
			s_hidden.Clear();
			for (int j = 0; j < s_off.Count; j++)
			{
				Light val2 = s_off[j];
				if ((Object)(object)val2 != (Object)null)
				{
					((Behaviour)val2).enabled = true;
				}
			}
			s_off.Clear();
		}

		internal static void Clear()
		{
			Forget();
			s_parts.Clear();
			s_particlesOf.Clear();
			s_lightDistant.Clear();
		}

		private static void Forget()
		{
			Show();
			for (int num = s_zones.Count - 1; num >= 0; num--)
			{
				Drop(num);
			}
			s_lights.Clear();
			s_lively.Clear();
			s_clutter.Clear();
			s_clutterNext.Clear();
			s_clutterCursor = 0;
			s_clutterHas = false;
			s_version = int.MinValue;
			s_listsAt = 0f;
			LabZones = (LabZonesInView = 0);
		}

		private static int Index(int x, int y)
		{
			uint num = (uint)(x + 256);
			uint num2 = (uint)(y + 256);
			if (num >= 512 || num2 >= 512)
			{
				return -1;
			}
			return (int)(num2 * 512 + num);
		}

		private static Zone ZoneAt(int index)
		{
			int num = ((index >= 0 && s_zoneOf != null) ? (s_zoneOf[index] - 1) : (-1));
			if (num < 0)
			{
				return null;
			}
			return s_zones[num];
		}

		private static Zone ZoneAt(Vector3 point)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			Vector2s zone = ZoneSystem.GetZone(point);
			return ZoneAt(Index(zone.x, zone.y));
		}

		private static void Zones(RemoteAreas areas, float now)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: 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_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: 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_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: 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)
			ZNet instance = ZNet.instance;
			Vector2s zone = ZoneSystem.GetZone(instance.GetReferencePosition());
			SimulationDistance syncedSimulationDistance = instance.GetSyncedSimulationDistance();
			bool flag = areas.AreasVersion != s_version || zone != s_me || ((SimulationDistance)(ref syncedSimulationDistance)).NearSimulationDistance != s_near || ((SimulationDistance)(ref syncedSimulationDistance)).TotalSimulationDistance != s_total || ((SimulationDistance)(ref syncedSimulationDistance)).IsClassic != s_classic;
			if (!flag && now < s_zonesAt)
			{
				return;
			}
			s_zonesAt = now + 1f;
			if (flag)
			{
				s_listsAt = 0f;
			}
			s_version = areas.AreasVersion;
			s_me = zone;
			s_near = ((SimulationDistance)(ref syncedSimulationDistance)).NearSimulationDistance;
			s_total = ((SimulationDistance)(ref syncedSimulationDistance)).TotalSimulationDistance;
			s_classic = ((SimulationDistance)(ref syncedSimulationDistance)).IsClassic;
			s_set.Clear();
			for (int i = 0; i < areas.Count; i++)
			{
				List<Vector2s> list = areas.AreaZones(i);
				for (int j = 0; j < list.Count; j++)
				{
					if (!NearHas(list[j]))
					{
						s_set.Add(list[j]);
					}
				}
			}
			if (s_zoneOf == null)
			{
				s_zoneOf = new int[262144];
			}
			s_mark++;
			foreach (Vector2s item in s_set)
			{
				int num = Index(item.x, item.y);
				if (num >= 0)
				{
					Zone zone2 = ZoneAt(num);
					if (zone2 == null)
					{
						zone2 = ((s_pool.Count > 0) ? s_pool.Pop() : new Zone());
						zone2.Reset(item, num);
						s_zones.Add(zone2);
						s_zoneOf[num] = s_zones.Count;
					}
					zone2.Mark = s_mark;
					zone2.Near = NearHas(item);
					zone2.Ring = RingHas(item);
				}
			}
			s_set.Clear();
			ZoneSystem instance2 = ZoneSystem.instance;
			for (int num2 = s_zones.Count - 1; num2 >= 0; num2--)
			{
				Zone zone3 = s_zones[num2];
				if (zone3.Mark != s_mark)
				{
					if (instance2.IsZoneLoaded(zone3.Id) && !NearHas(zone3.Id))
					{
						zone3.Mark = s_mark;
						zone3.Near = false;
						zone3.Ring = RingHas(zone3.Id);
					}
					else
					{
						Drop(num2);
					}
				}
			}
			LabZones = s_zones.Count;
		}

		private static void Drop(int i)
		{
			Zone zone = s_zones[i];
			s_zoneOf[zone.Index] = 0;
			int num = s_zones.Count - 1;
			if (i != num)
			{
				Zone zone2 = s_zones[num];
				s_zones[i] = zone2;
				s_zoneOf[zone2.Index] = i + 1;
			}
			s_zones.RemoveAt(num);
			zone.Clear();
			s_pool.Push(zone);
		}

		private static bool NearHas(Vector2s z)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Max(Mathf.Abs(z.x - s_me.x), Mathf.Abs(z.y - s_me.y));
			if (num <= s_near)
			{
				if (!s_classic && num != 0)
				{
					return ZoneSystem.instance.ZonesWithinRadius(s_me, z, s_near, false);
				}
				return true;
			}
			return false;
		}

		private static bool RingHas(Vector2s z)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Max(Mathf.Abs(z.x - s_me.x), Mathf.Abs(z.y - s_me.y));
			if (num <= s_total)
			{
				if (!s_classic && num != 0)
				{
					return ZoneSystem.instance.ZonesWithinRadius(s_me, z, s_total, true);
				}
				return true;
			}
			return false;
		}

		private static bool GameHas(Vector2s z, bool distant)
		{
			//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)
			if (!NearHas(z))
			{
				if (distant)
				{
					return RingHas(z);
				}
				return false;
			}
			return true;
		}

		private static void ListGround()
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < s_zones.Count; i++)
			{
				Zone zone = s_zones[i];
				zone.Ground.Clear();
				zone.HasGround = false;
			}
			List<Heightmap> allHeightmaps = Heightmap.GetAllHeightmaps();
			for (int j = 0; j < allHeightmaps.Count; j++)
			{
				Heightmap val = allHeightmaps[j];
				if (!((Object)(object)val == (Object)null))
				{
					Zone zone2 = ZoneAt(((Component)val).transform.position);
					MeshRenderer val2 = ((zone2 != null) ? s_heightmapRenderer.Invoke(val) : null);
					if (!((Object)(object)val2 == (Object)null))
					{
						zone2.Ground.Add((Renderer)(object)val2);
						Bounds bounds = ((Renderer)val2).bounds;
						Spans(zone2, ((Bounds)(ref bounds)).min.y, ((Bounds)(ref bounds)).max.y);
					}
				}
			}
			List<WaterVolume> instances = WaterVolume.Instances;
			for (int k = 0; k < instances.Count; k++)
			{
				WaterVolume val3 = instances[k];
				if (!((Object)(object)val3 == (Object)null) && !((Object)(object)val3.m_waterSurface == (Object)null))
				{
					Zone zone3 = ZoneAt(((Component)val3).transform.position);
					if (zone3 != null)
					{
						zone3.Ground.Add((Renderer)(object)val3.m_waterSurface);
						float y = ((Component)val3.m_waterSurface).transform.position.y;
						Spans(zone3, y, y);
					}
				}
			}
		}

		private static void Spans(Zone z, float min, float max)
		{
			if (!z.HasGround)
			{
				z.HasGround = true;
				z.MinY = min;
				z.MaxY = max;
			}
			else
			{
				z.MinY = Mathf.Min(z.MinY, min);
				z.MaxY = Mathf.Max(z.MaxY, max);
			}
		}

		private static void ListLights()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			s_lights.Clear();
			HashSet<LightLod> hashSet = s_lodLights.Invoke();
			if (hashSet == null)
			{
				return;
			}
			if (s_lightDistant.Count > 4096)
			{
				s_lightDistant.Clear();
			}
			foreach (LightLod item in hashSet)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				Vector2s zone = ZoneSystem.GetZone(((Component)item).transform.position);
				int index = Index(zone.x, zone.y);
				if (ZoneAt(index) == null)
				{
					continue;
				}
				Light val = s_lodLight.Invoke(item);
				if (!((Object)(object)val == (Object)null))
				{
					if (!s_lightDistant.TryGetValue(item, out var value))
					{
						ZNetView componentInParent = ((Component)item).GetComponentInParent<ZNetView>();
						value = (Object)(object)componentInParent != (Object)null && componentInParent.m_distant;
						s_lightDistant[item] = value;
					}
					s_lights.Add(new LightEntry
					{
						Light = val,
						Index = index,
						Distant = value
					});
				}
			}
		}

		private static void ListLively(RemoteAreas areas)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_0067: 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_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			s_lively.Clear();
			s_points.Clear();
			float num = 0f;
			for (int i = 0; i < areas.Count; i++)
			{
				Vector2s val = areas.AreaZone(i);
				s_points.Add(ZoneSystem.GetZonePos(val));
				List<Vector2s> list = areas.AreaZones(i);
				int num2 = 0;
				for (int j = 0; j < list.Count; j++)
				{
					num2 = Mathf.Max(num2, Mathf.Max(Mathf.Abs(list[j].x - val.x), Mathf.Abs(list[j].y - val.y)));
				}
				num = Mathf.Max(num, (float)(num2 + 1) * 64f * 1.4143f);
			}
			if (s_points.Count == 0)
			{
				return;
			}
			if (s_particlesOf.Count > 20000)
			{
				s_particlesOf.Clear();
			}
			areas.InstancesNear(s_points, num, s_views, draining: true);
			for (int k = 0; k < s_views.Count; k++)
			{
				ZNetView val2 = s_views[k];
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				Vector2s zone = ZoneSystem.GetZone(((Component)val2).transform.position);
				int index = Index(zone.x, zone.y);
				if (ZoneAt(index) != null)
				{
					if (!s_particlesOf.TryGetValue(val2, out var value))
					{
						((Component)val2).GetComponentsInChildren<ParticleSystemRenderer>(true, s_particles);
						value = ((s_particles.Count > 0) ? s_particles.ToArray() : s_noParticles);
						s_particles.Clear();
						s_particlesOf[val2] = value;
					}
					if (value.Length != 0)
					{
						ZDO zDO = val2.GetZDO();
						s_lively.Add(new Lively
						{
							Renderers = value,
							Root = ((Component)val2).transform,
							Index = index,
							Distant = ((zDO != null) ? zDO.Distant : val2.m_distant)
						});
					}
				}
			}
			s_views.Clear();
		}

		private static void ListClutter()
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: 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_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			ClutterSystem instance = ClutterSystem.instance;
			GameObject val = (((Object)(object)instance != (Object)null) ? s_grassRoot.Invoke(instance) : null);
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)val == (Object)null || (Object)(object)localPlayer == (Object)null)
			{
				s_clutter.Clear();
				s_clutterNext.Clear();
				s_clutterCursor = 0;
				s_clutterHas = false;
				return;
			}
			Transform transform = val.transform;
			int childCount = transform.childCount;
			Vector3 position = ((Component)localPlayer).transform.position;
			float num = instance.m_distance + instance.m_grassPatchSize * 0.75f;
			bool num2 = s_clutterHas && Utils.DistanceXZ(position, s_clutterFrom) > instance.m_grassPatchSize;
			s_clutterFrom = position;
			s_clutterHas = true;
			if (num2)
			{
				int num3 = 0;
				for (int i = 0; i < s_clutter.Count; i++)
				{
					Renderer val2 = s_clutter[i];
					if (!((Object)(object)val2 == (Object)null) && !(Utils.DistanceXZ(((Component)val2).transform.position, position) <= num))
					{
						s_clutter[num3++] = val2;
					}
				}
				s_clutter.RemoveRange(num3, s_clutter.Count - num3);
				s_clutterNext.Clear();
				s_clutterCursor = 0;
			}
			int num4 = Mathf.Min(childCount, s_clutterCursor + 256);
			InstanceRenderer val3 = default(InstanceRenderer);
			for (int j = s_clutterCursor; j < num4; j++)
			{
				Transform child = transform.GetChild(j);
				if (!((Component)child).TryGetComponent<InstanceRenderer>(ref val3) && !(Utils.DistanceXZ(child.position, position) <= num))
				{
					((Component)child).GetComponentsInChildren<Renderer>(true, s_renderers);
					s_clutterNext.AddRange(s_renderers);
					s_renderers.Clear();
				}
			}
			s_clutterCursor = num4;
			if (num4 >= childCount)
			{
				List<Renderer> list = s_clutterNext;
				s_clutterNext = s_clutter;
				s_clutter = list;
				s_clutterNext.Clear();
				s_clutterCursor = 0;
			}
		}

		private static void Sweep()
		{
			if (s_parts.Count > 4096)
			{
				foreach (KeyValuePair<ZNetView, Parts> s_part in s_parts)
				{
					if ((Object)(object)s_part.Key == (Object)null)
					{
						s_gone.Add(s_part.Key);
					}
				}
				for (int i = 0; i < s_gone.Count; i++)
				{
					s_parts.Remove(s_gone[i]);
				}
				s_gone.Clear();
			}
			if (s_parts.Count > 60000)
			{
				s_parts.Clear();
			}
		}

		private static void View(Camera cam)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: 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)
			GeometryUtility.CalculateFrustumPlanes(cam, s_planes);
			Vector3 position = ((Component)cam).transform.position;
			float shadowDistance = QualitySettings.shadowDistance;
			float num = ((WindowLayerCull.Radius > 0f) ? WindowLayerCull.Radius : float.MaxValue);
			int num2 = 0;
			Vector3 val = default(Vector3);
			Vector3 val2 = default(Vector3);
			for (int i = 0; i < s_zones.Count; i++)
			{
				Zone zone = s_zones[i];
				Vector3 zonePos = ZoneSystem.GetZonePos(zone.Id);
				float num3 = (zone.HasGround ? (zone.MinY - 32f) : (-1000f));
				float num4 = (zone.HasGround ? (zone.MaxY + 96f) : 3000f);
				((Vector3)(ref val))..ctor(zonePos.x - 48f, num3, zonePos.z - 48f);
				((Vector3)(ref val2))..ctor(zonePos.x + 48f, num4, zonePos.z + 48f);
				Vector3 val3 = Vector3.Max(val, Vector3.Min(val2, position));
				float num5 = (zone.Distance = Vector3.Distance(position, val3));
				zone.InView = num5 < shadowDistance || InFrustum(val, val2);
				zone.Close = num5 < num;
				if (zone.InView)
				{
					num2++;
				}
			}
			LabZonesInView = num2;
		}

		private static bool InFrustum(Vector3 min, Vector3 max)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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_0027: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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)
			Vector3 val = default(Vector3);
			for (int i = 0; i < s_planes.Length; i++)
			{
				Vector3 normal = ((Plane)(ref s_planes[i])).normal;
				((Vector3)(ref val))..ctor((normal.x >= 0f) ? max.x : min.x, (normal.y >= 0f) ? max.y : min.y, (normal.z >= 0f) ? max.z : min.z);
				if (Vector3.Dot(normal, val) + ((Plane)(ref s_planes[i])).distance < 0f)
				{
					return false;
				}
			}
			return true;
		}

		private static void ListObjects(int version, float now)
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			s_watch.Restart();
			int num = 0;
			List<ZDO>[] array = s_objectsBySector.Invoke(ZDOMan.instance);
			ZNetScene instance = ZNetScene.instance;
			while (true)
			{
				Zone zone = NextToList(version, now);
				if (zone == null)
				{
					break;
				}
				if (zone.Cursor < 0)
				{
					zone.Snapshot.Clear();
					zone.Next.Clear();
					List<ZDO> list = ((array != null && zone.Index < array.Length) ? array[zone.Index] : null);
					if (list != null)
					{
						zone.Snapshot.AddRange(list);
					}
					zone.Cursor = 0;
				}
				while (zone.Cursor < zone.Snapshot.Count)
				{
					if (num >= 8 && s_watch.Elapsed.TotalMilliseconds >= 0.25)
					{
						return;
					}
					ZDO val = zone.Snapshot[zone.Cursor++];
					num++;
					if (val == null || val.GetSector() != zone.Id)
					{
						continue;
					}
					ZNetView val2 = instance.FindInstance(val);
					if (!((Object)(object)val2 == (Object)null))
					{
						Parts parts = PartsOf(val2, now);
						if (parts.Renderers.Length != 0)
						{
							zone.Next.Add(new Item
							{
								Parts = parts,
								Distant = val.Distant
							});
							LabListed++;
						}
					}
				}
				List<Item> items = zone.Items;
				zone.Items = zone.Next;
				zone.Next = items;
				zone.Next.Clear();
				zone.Snapshot.Clear();
				zone.Cursor = -1;
				zone.ListedVersion = version;
				zone.ListedAt = now;
			}
		}

		private static Zone NextToList(int version, float now)
		{
			Zone result = null;
			int num = int.MaxValue;
			float num2 = float.MaxValue;
			for (int i = 0; i < s_zones.Count; i++)
			{
				Zone zone = s_zones[i];
				int num3;
				if (zone.Cursor >= 0)
				{
					num3 = 0;
				}
				else
				{
					if (!zone.Close || (zone.ListedVersion == version && !(now - zone.ListedAt >= 2f)))
					{
						continue;
					}
					num3 = (zone.InView ? 1 : 2);
				}
				if (num3 < num || (num3 == num && zone.Distance < num2))
				{
					result = zone;
					num = num3;
					num2 = zone.Distance;
				}
			}
			return result;
		}

		private static Parts PartsOf(ZNetView v, float now)
		{
			if (s_parts.TryGetValue(v, out var value) && now - value.ListedAt < 10f)
			{
				return value;
			}
			if (value == null)
			{
				value = new Parts
				{
					View = v
				};
				s_parts[v] = value;
			}
			value.ListedAt = now;
			Fill(value, v);
			return value;
		}

		private static void Fill(Parts p, ZNetView v)
		{
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: 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_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			((Component)v).GetComponentsInChildren<Renderer>(true, s_renderers);
			int count = s_renderers.Count;
			Character val = default(Character);
			Rigidbody val2 = default(Rigidbody);
			bool flag = ((Component)v).TryGetComponent<Character>(ref val) || ((Component)v).TryGetComponent<Rigidbody>(ref val2);
			if (!flag && !p.Mover && p.Renderers != null && SameRenderers(p.Renderers, s_renderers))
			{
				s_renderers.Clear();
				return;
			}
			if (p.Renderers == null || p.Renderers.Length != count)
			{
				p.Renderers = (Renderer[])(object)new Renderer[count];
				p.Level = new sbyte[count];
				p.Group = new short[count];
			}
			s_renderers.CopyTo(p.Renderers);
			s_renderers.Clear();
			p.Mover = flag;
			p.Root = (p.Mover ? ((Component)v).transform : null);
			for (int i = 0; i < count; i++)
			{
				p.Level[i] = -1;
				p.Group[i] = -1;
			}
			int num = 0;
			if (!p.Mover && count > 0)
			{
				((Component)v).GetComponentsInChildren<LODGroup>(true, s_groups);
				for (int j = 0; j < s_groups.Count; j++)
				{
					if (num >= 32767)
					{
						break;
					}
					LODGroup val3 = s_groups[j];
					if ((Object)(object)val3 == (Object)null || !val3.enabled)
					{
						continue;
					}
					LOD[] lODs = val3.GetLODs();
					if (lODs.Length == 0)
					{
						continue;
					}
					if (p.GroupAt == null || p.GroupAt.Length <= num)
					{
						Array.Resize(ref p.GroupAt, num + 1);
						Array.Resize(ref p.GroupSize, num + 1);
						Array.Resize(ref p.Heights, num + 1);
					}
					Transform transform = ((Component)val3).transform;
					Vector3 lossyScale = transform.lossyScale;
					p.GroupAt[num] = transform.TransformPoint(val3.localReferencePoint);
					p.GroupSize[num] = val3.size * Mathf.Max(Mathf.Abs(lossyScale.x), Mathf.Max(Mathf.Abs(lossyScale.y), Mathf.Abs(lossyScale.z)));
					float[] array = ((p.Heights[num] != null && p.Heights[num].Length == lODs.Length) ? p.Heights[num] : new float[lODs.Length]);
					for (int k = 0; k < lODs.Length && k < 127; k++)
					{
						array[k] = lODs[k].screenRelativeTransitionHeight;
						Renderer[] renderers = lODs[k].renderers;
						if (renderers == null)
						{
							continue;
						}
						for (int l = 0; l < renderers.Length; l++)
						{
							if ((Object)(object)renderers[l] != (Object)null && !s_lodOf.ContainsKey(renderers[l]))
							{
								s_lodOf[renderers[l]] = (num << 8) | k;
							}
						}
					}
					p.Heights[num] = array;
					num++;
				}
				s_groups.Clear();
				if (s_lodOf.Count > 0)
				{
					for (int m = 0; m < count; m++)
					{
						if ((Object)(object)p.Renderers[m] != (Object)null && s_lodOf.TryGetValue(p.Renderers[m], out var value))
						{
							p.Group[m] = (short)(value >> 8);
							p.Level[m] = (sbyte)(value & 0xFF);
						}
					}
					s_lodOf.Clear();
				}
			}
			if (p.GroupAt != null && p.GroupAt.Length != num)
			{
				Array.Resize(ref p.GroupAt, num);
				Array.Resize(ref p.GroupSize, num);
				Array.Resize(ref p.Heights, num);
			}
		}

		private static bool SameRenderers(Renderer[] had, List<Renderer> now)
		{
			if (had.Length != now.Count)
			{
				return false;
			}
			for (int i = 0; i < had.Length; i++)
			{
				if (had[i] != now[i])
				{
					return false;
				}
			}
			return true;
		}

		private static void Apply(Camera cam)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)cam).transform.position;
			float tanHalf = Mathf.Tan(cam.fieldOfView * 0.5f * (MathF.PI / 180f));
			float lodBias = QualitySettings.lodBias;
			int maximumLODLevel = QualitySettings.maximumLODLevel;
			for (int i = 0; i < s_zones.Count; i++)
			{
				Zone zone = s_zones[i];
				if (!zone.Near && zone.InView)
				{
					for (int j = 0; j < zone.Ground.Count; j++)
					{
						Off(zone.Ground[j]);
					}
					if (zone.Close)
					{
						HideObjects(zone, position, tanHalf, lodBias, maximumLODLevel);
					}
				}
			}
			for (int k = 0; k < s_lights.Count; k++)
			{
				LightEntry lightEntry = s_lights[k];
				Zone zone2 = ZoneAt(lightEntry.Index);
				if (zone2 != null && !zone2.Near && (!lightEntry.Distant || !zone2.Ring))
				{
					Light light = lightEntry.Light;
					if ((Object)(object)light != (Object)null && ((Behaviour)light).enabled)
					{
						((Behaviour)light).enabled = false;
						s_off.Add(light);
					}
				}
			}
			for (int l = 0; l < s_lively.Count; l++)
			{
				Lively lively = s_lively[l];
				Zone zone3 = ZoneAt(lively.Index);
				if (zone3 != null && zone3.InView && !zone3.Near && (!lively.Distant || !zone3.Ring) && (Crossing.Count <= 0 || !((Object)(object)lively.Root != (Object)null) || !Crossing.Contains(lively.Root)))
				{
					ParticleSystemRenderer[] renderers = lively.Renderers;
					for (int m = 0; m < renderers.Length; m++)
					{
						Off((Renderer)(object)renderers[m]);
					}
				}
			}
			for (int n = 0; n < s_clutter.Count; n++)
			{
				Off(s_clutter[n]);
			}
			if (FarViewer.FarPuffs.Count > 0)
			{
				HidePuffs();
			}
		}

		private static void HidePuffs()
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			SmokeRenderer instance = SmokeRenderer.Instance;
			Dictionary<Vector3Int, List<Smoke>> dictionary = (((Object)(object)instance != (Object)null) ? s_smokeChunks.Invoke(instance) : null);
			Dictionary<Vector3Int, ParticleSystem> dictionary2 = (((Object)(object)instance != (Object)null) ? s_smokeSystems.Invoke(instance) : null);
			if (dictionary == null || dictionary2 == null)
			{
				return;
			}
			HashSet<Smoke> farPuffs = FarViewer.FarPuffs;
			ParticleSystemRenderer r = default(ParticleSystemRenderer);
			foreach (KeyValuePair<Vector3Int, List<Smoke>> item in dictionary)
			{
				List<Smoke> value = item.Value;
				if (value != null && value.Count != 0)
				{
					bool flag = true;
					for (int i = 0; i < value.Count && flag; i++)
					{
						flag = farPuffs.Contains(value[i]);
					}
					if (flag && dictionary2.TryGetValue(item.Key, out var value2) && (Object)(object)value2 != (Object)null && ((Component)value2).TryGetComponent<ParticleSystemRenderer>(ref r))
					{
						Off((Renderer)(object)r);
					}
				}
			}
		}

		private static void HideObjects(Zone z, Vector3 eye, float tanHalf, float bias, int lowest)
		{
			//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_0106: Unknown result type (might be due to invalid IL or missing references)
			List<Item> items = z.Items;
			for (int i = 0; i < items.Count; i++)
			{
				Item item = items[i];
				Parts parts = item.Parts;
				if ((Object)(object)parts.View == (Object)null)
				{
					continue;
				}
				Renderer[] renderers = parts.Renderers;
				if (parts.Mover)
				{
					if (!((Object)(object)parts.Root == (Object)null) && (Crossing.Count <= 0 || !Crossing.Contains(parts.Root)) && !GameHas(ZoneSystem.GetZone(parts.Root.position), item.Distant))
					{
						for (int j = 0; j < renderers.Length; j++)
						{
							Off(renderers[j]);
						}
					}
				}
				else
				{
					if (item.Distant && z.Ring)
					{
						continue;
					}
					int num = ((parts.GroupAt != null) ? parts.GroupAt.Length : 0);
					if (s_level.Length < num)
					{
						s_level = new int[Mathf.NextPowerOfTwo(num)];
					}
					for (int k = 0; k < num; k++)
					{
						s_level[k] = Pick(parts, k, eye, tanHalf, bias, lowest);
					}
					for (int l = 0; l < renderers.Length; l++)
					{
						int num2 = parts.Group[l];
						if (num2 >= 0)
						{
							int num3 = s_level[num2];
							if (num3 == -100 || Mathf.Abs(parts.Level[l] - num3) > 1)
							{
								continue;
							}
						}
						Off(renderers[l]);
					}
				}
			}
		}

		private static int Pick(Parts p, int g, Vector3 eye, float tanHalf, float bias, int lowest)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			float[] array = p.Heights[g];
			int num = array.Length;
			float num2 = Vector3.Distance(eye, p.GroupAt[g]);
			float num3 = ((num2 > 0.001f && tanHalf > 0f) ? (p.GroupSize[g] / (2f * num2 * tanHalf) * bias) : float.MaxValue);
			for (int i = Mathf.Clamp(lowest, 0, num - 1); i < num; i++)
			{
				if (num3 >= array[i])
				{
					return i;
				}
			}
			if (!(num3 >= array[num - 1] * 0.75f))
			{
				return -100;
			}
			return num - 1;
		}

		private static void Off(Renderer r)
		{
			if (!((Object)(object)r == (Object)null) && !r.forceRenderingOff)
			{
				r.forceRenderingOff = true;
				s_hidden.Add(r);
			}
		}
	}
	internal static class DebugDump
	{
		private static readonly Color Magenta = new Color(1f, 0f, 1f, 1f);

		internal static string Write(PortalRenderer renderer, Camera main, List<PortalWindow> windows)
		{
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: 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_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_044f: 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_054d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0552: Unknown result type (might be due to invalid IL or missing references)
			//IL_055a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0576: Unknown result type (might be due to invalid IL or missing references)
			PortalWindow portalWindow = (from x in windows
				where x.Enabled && x.Partner != null
				orderby Vector3.Distance(x.Frame.Center, ((Component)main).transform.position)
				select x).FirstOrDefault();
			if (portalWindow == null)
			{
				Plugin.Log.LogInfo((object)"Debug dump: no live portal window");
				return null;
			}
			string text = Path.Combine(Paths.BepInExRootPath, "RealPortalDebug", DateTime.Now.ToString("yyyyMMdd_HHmmss"));
			Directory.CreateDirectory(text);
			int num = Mathf.Max(64, main.pixelWidth / 2);
			int num2 = Mathf.Max(64, main.pixelHeight / 2);
			RenderTexture val = new RenderTexture(num, num2, 24, (RenderTextureFormat)0)
			{
				antiAliasing = 1
			};
			val.Create();
			StringBuilder stringBuilder = new StringBuilder();
			try
			{
				Vector3 val2 = PortalRenderer.ViewPosition(portalWindow, ((Component)main).transform.position);
				object[] obj = new object[5]
				{
					((Component)main).transform.position,
					null,
					null,
					null,
					null
				};
				Quaternion rotation = ((Component)main).transform.rotation;
				obj[1] = ((Quaternion)(ref rotation)).eulerAngles;
				obj[2] = main.fieldOfView;
				obj[3] = main.nearClipPlane;
				obj[4] = main.actualRenderingPath;
				stringBuilder.AppendLine(string.Format("main camera {0} rot {1}, fov {2}, near {3}, path {4}", obj));
				stringBuilder.AppendLine($"entry centre {portalWindow.Frame.Center} fwd {portalWindow.Frame.Forward}; exit centre {portalWindow.Partner.Frame.Center} fwd {portalWindow.Partner.Frame.Forward}");
				stringBuilder.AppendLine($"window camera {val2}, {portalWindow.Partner.Frame.SignedDistance(val2):0.00} m from the exit plane");
				if ((Object)(object)ZoneSystem.instance != (Object)null)
				{
					stringBuilder.AppendLine($"ground under window camera {ZoneSystem.instance.GetGroundHeight(val2):0.00}, liquid {Floating.GetLiquidLevel(val2, 1f, (LiquidType)10):0.00}");
				}
				stringBuilder.AppendLine($"settings: path {renderer.Settings.RenderingPath}, clear {renderer.Settings.ClearFlags}, far {renderer.Settings.FarClip}, " + $"res {renderer.Settings.Resolution}, pixel lights {QualitySettings.pixelLightCount}");
				renderer.RenderDebug(main, windows, portalWindow, val, main.cullingMask, null);
				Save(val, Path.Combine(text, "view.png"), out var _);
				WriteLive(renderer, main, windows, portalWindow, text, stringBuilder);
				stringBuilder.AppendLine();
				stringBuilder.AppendLine("layers drawn in the window (pixels not magenta):");
				for (int num3 = 0; num3 < 32; num3++)
				{
					string arg = LayerMask.LayerToName(num3);
					if ((main.cullingMask & (1 << num3)) != 0)
					{
						renderer.RenderDebug(main, windows, portalWindow, val, 1 << num3, Magenta);
						Read(val, out var tex2);
						int num4 = tex2.GetPixels32().Count((Color32 c) => c.r <= 250 || c.g >= 5 || c.b <= 250);
						if (num4 > 0)
						{
							File.WriteAllBytes(Path.Combine(text, $"layer_{num3:00}_{arg}.png"), ImageConversion.EncodeToPNG(tex2));
							stringBuilder.AppendLine($"  {num3,2} {arg,-20} {100f * (float)num4 / (float)(num * num2):0.0}%");
						}
						Object.Destroy((Object)(object)tex2);
					}
				}
				stringBuilder.AppendLine();
				stringBuilder.AppendLine("renderers within 40 m of the window camera on the camera side of the exit plane (should be clipped):");
				foreach (string item in BehindExit(portalWindow, val2))
				{
					stringBuilder.AppendLine("  " + item);
				}
			}
			catch (Exception ex)
			{
				stringBuilder.AppendLine("ERROR " + ex);
			}
			finally
			{
				val.Release();
				Object.Destroy((Object)(object)val);
			}
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("window camera components and command buffers:");
			Behaviour[] components = ((Component)renderer.Camera).GetComponents<Behaviour>();
			foreach (Behaviour val3 in components)
			{
				stringBuilder.AppendLine($"  component {((object)val3).GetType().FullName} enabled {val3.enabled}");
			}
			foreach (CameraEvent value in Enum.GetValues(typeof(CameraEvent)))
			{
				CommandBuffer[] commandBuffers = renderer.Camera.GetCommandBuffers(value);
				foreach (CommandBuffer val5 in commandBuffers)
				{
					stringBuilder.AppendLine($"  {(object)value}: {val5.name}");
				}
			}
			File.WriteAllText(Path.Combine(text, "info.txt"), stringBuilder.ToString());
			Plugin.Log.LogInfo((object)("Debug dump written to " + text));
			return text;
		}

		internal static void LiveFrame(Camera main, List<PortalWindow> windows, string dir, int index)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			PortalWindow portalWindow = (from x in windows
				where x.Enabled && x.Partner != null && x.RenderedThisFrame && (Object)(object)x.Texture != (Object)null
				orderby Vector3.Distance(x.Frame.Center, ((Component)main).transform.position)
				select x).FirstOrDefault();
			if (portalWindow != null)
			{
				RenderTexture val = new RenderTexture(((Texture)portalWindow.Texture).width, ((Texture)portalWindow.Texture).height, 0, (RenderTextureFormat)0);
				val.Create();
				Graphics.Blit((Texture)(object)portalWindow.Texture, val);
				Save(val, Path.Combine(dir, $"window_frame{index}_f{Time.frameCount}.png"), out var _);
				val.Release();
				Object.Destroy((Object)(object)val);
			}
		}

		private static void WriteLive(PortalRenderer renderer, Camera main, List<PortalWindow> windows, PortalWindow w, string dir, StringBuilder info)
		{
			//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_005e: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//IL_00d0: 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 (!w.RenderedThisFrame || (Object)(object)w.Texture == (Object)null)
			{
				info.AppendLine("live window texture: not rendered this frame");
				return;
			}
			RenderTexture texture = w.Texture;
			Rect textureRect = w.TextureRect;
			info.AppendLine($"live window texture {((Texture)texture).width}x{((Texture)texture).height} {texture.format}, screen rect {textureRect}");
			RenderTexture val = new RenderTexture(((Texture)texture).width, ((Texture)texture).height, 24, (RenderTextureFormat)0)
			{
				antiAliasing = 1
			};
			val.Create();
			try
			{
				Graphics.Blit((Texture)(object)texture, val);
				Save(val, Path.Combine(dir, "window_live.png"), out var tex);
				renderer.RenderDebug(main, windows, w, val, main.cullingMask, null, textureRect, 0f);
				Save(val, Path.Combine(dir, "window_noshadows.png"), out tex);
				renderer.RenderDebug(main, windows, w, val, main.cullingMask, null, textureRect, QualitySettings.shadowDistance);
				Save(val, Path.Combine(dir, "window_shadows.png"), out tex);
			}
			finally
			{
				val.Release();
				Object.Destroy((Object)(object)val);
			}
		}

		private static IEnumerable<string> BehindExit(PortalWindow w, Vector3 camPos)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			PortalFrame exit = w.Partner.Frame;
			float camSide = Mathf.Sign(exit.SignedDistance(camPos));
			return Object.FindObjectsByType<Renderer>((FindObjectsSortMode)0).Where(delegate(Renderer r)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				if (r.enabled && ((Component)r).gameObject.activeInHierarchy)
				{
					Bounds bounds = r.bounds;
					if (((Bounds)(ref bounds)).SqrDistance(camPos) < 1600f)
					{
						PortalFrame portalFrame = exit;
						bounds = r.bounds;
						return Mathf.Sign(portalFrame.SignedDistance(((Bounds)(ref bounds)).center)) == camSide;
					}
				}
				return false;
			}).OrderBy(delegate(Renderer r)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				Bounds bounds = r.bounds;
				return ((Bounds)(ref bounds)).SqrDistance(camPos);
			})
				.Take(40)
				.Select(delegate(Renderer r)
				{
					//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_008b: Unknown result type (might be due to invalid IL or missing references)
					string[] obj = new string[7]
					{
						NameOf(((Component)r).transform),
						" layer ",
						LayerMask.LayerToName(((Component)r).gameObject.layer),
						", shader ",
						((Object)(object)r.sharedMaterial != (Object)null && (Object)(object)r.sharedMaterial.shader != (Object)null) ? ((Object)r.sharedMaterial.shader).name : "none",
						", ",
						null
					};
					Bounds bounds = r.bounds;
					obj[6] = $"{Mathf.Sqrt(((Bounds)(ref bounds)).SqrDistance(camPos)):0.0} m";
					return string.Concat(obj);
				});
		}

		private static string NameOf(Transform t)
		{
			if (!((Object)(object)t.parent != (Object)null))
			{
				return ((Object)t).name;
			}
			return ((Object)t.parent).name + "/" + ((Object)t).name;
		}

		private static void Read(RenderTexture rt, out Texture2D tex)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			RenderTexture active = RenderTexture.active;
			RenderTexture.active = rt;
			tex = new Texture2D(((Texture)rt).width, ((Texture)rt).height, (TextureFormat)3, false);
			tex.ReadPixels(new Rect(0f, 0f, (float)((Texture)rt).width, (float)((Texture)rt).height), 0, 0);
			tex.Apply();
			RenderTexture.active = active;
		}

		private static void Save(RenderTexture rt, string path, out Texture2D tex)
		{
			Read(rt, out tex);
			File.WriteAllBytes(path, ImageConversion.EncodeToPNG(tex));
			Object.Destroy((Object)(object)tex);
		}
	}
	[HarmonyPatch]
	internal static class FarDrain
	{
		internal static int LabQuietPokes;

		[HarmonyPrefix]
		[HarmonyPatch(typeof(TerrainModifier), "PokeHeightmaps")]
		private static bool PokeHeightmaps(TerrainModifier __instance, bool forcedDelay)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (!FarFlags.DrainCalm || forcedDelay)
			{
				return true;
			}
			RemoteAreas remoteAreas = PortalSystem.Instance?.Areas;
			if (remoteAreas == null || !remoteAreas.UnloadsQuietly(((Component)__instance).transform.position))
			{
				return true;
			}
			LabQuietPokes++;
			return false;
		}
	}
	internal static class FarHeightmaps
	{
		private const float GoneSeconds = 120f;

		private const float RefreshSeconds = 1f;

		internal static readonly Func<Vector3, Place> Hook = PlaceOf;

		private static Dictionary<int, float> s_unloading = new Dictionary<int, float>();

		private static Dictionary<int, float> s_next = new Dictionary<int, float>();

		private static readonly List<Vector2s> s_live = new List<Vector2s>();

		private static int s_liveReach;

		private static int s_near;

		private static int s_whole;

		private static int s_areaNear;

		private static RemoteAreas s_areas;

		private static int s_version = -1;

		private static float s_refreshAt;

		private static int s_meFrame = -1;

		private static Vector2s s_me;

		internal static long LabNear;

		internal static long LabFar;

		internal static long LabUnloading;

		internal static void Switched()
		{
			HeightmapIdleModule.PlaceOf = ((FarFlags.HeightmapDrainSkip || FarFlags.FarRegenBudget) ? Hook : null);
			HeightmapIdleModule.ForgetPlaces();
		}

		private static Place PlaceOf(Vector3 at)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			bool heightmapDrainSkip = FarFlags.HeightmapDrainSkip;
			bool farRegenBudget = FarFlags.FarRegenBudget;
			ZNet instance = ZNet.instance;
			if ((heightmapDrainSkip || farRegenBudget) && !((Object)(object)instance == (Object)null) && !((Object)(object)ZoneSystem.instance == (Object)null))
			{
				int frameCount = Time.frameCount;
				if (frameCount != s_meFrame)
				{
					s_meFrame = frameCount;
					s_me = ZoneSystem.GetZone(instance.GetReferencePosition());
				}
				RemoteAreas remoteAreas = PortalSystem.Instance?.Areas;
				float time = Time.time;
				if (remoteAreas != s_areas || (remoteAreas != null && remoteAreas.AreasVersion != s_version) || !(time < s_refreshAt))
				{
					Refresh(remoteAreas, instance, time);
				}
				Vector2s zone = ZoneSystem.GetZone(at);
				int num = Distance(zone, s_me);
				if (num <= s_near)
				{
					LabNear++;
					return (Place)0;
				}
				if (heightmapDrainSkip && num > s_whole && s_unloading.Count > 0 && s_unloading.ContainsKey(Key(zone)) && !Live(zone))
				{
					LabUnloading++;
					return (Place)2;
				}
				if (!farRegenBudget || Simulated(remoteAreas, zone) || (FarFlags.VisibleNear && remoteAreas != null && remoteAreas.ShowsZone(zone)))
				{
					LabNear++;
					return (Place)0;
				}
				LabFar++;
				return (Place)1;
			}
			return (Place)0;
		}

		private static void Refresh(RemoteAreas areas, ZNet net, float now)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			if (areas != s_areas)
			{
				s_unloading.Clear();
			}
			s_areas = areas;
			s_version = areas?.AreasVersion ?? (-1);
			s_refreshAt = now + 1f;
			ZoneSystem instance = ZoneSystem.instance;
			s_next.Clear();
			foreach (KeyValuePair<int, float> item in s_unloading)
			{
				if (now - item.Value < 120f && now >= item.Value && instance.IsZoneLoaded(Unkey(item.Key)))
				{
					s_next[item.Key] = item.Value;
				}
			}
			s_live.Clear();
			if (areas != null)
			{
				for (int i = 0; i < areas.Count; i++)
				{
					if (!areas.AreaDraining(i))
					{
						s_live.Add(areas.AreaZone(i));
						continue;
					}
					List<Vector2s> list = areas.AreaZones(i);
					for (int j = 0; j < list.Count; j++)
					{
						s_next[Key(list[j])] = now;
					}
				}
			}
			Dictionary<int, float> dictionary = s_unloading;
			s_unloading = s_next;
			s_next = dictionary;
			s_next.Clear();
			SimulationDistance syncedSimulationDistance = net.GetSyncedSimulationDistance();
			s_near = ((SimulationDistance)(ref syncedSimulationDistance)).NearSimulationDistance + 1;
			s_whole = ((SimulationDistance)(ref syncedSimulationDistance)).TotalSimulationDistance + 1;
			SimulationDistance val = RemoteAreas.AreaDistance();
			s_liveReach = ((SimulationDistance)(ref val)).TotalSimulationDistance;
			s_areaNear = ((SimulationDistance)(ref val)).NearSimulationDistance + 1;
		}

		private static bool Live(Vector2s zone)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < s_live.Count; i++)
			{
				if (Distance(zone, s_live[i]) <= s_liveReach)
				{
					return true;
				}
			}
			return false;
		}

		private static bool Simulated(RemoteAreas areas, Vector2s zone)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (areas == null)
			{
				return false;
			}
			for (int i = 0; i < areas.Count; i++)
			{
				if (areas.AreaSimulated(i) && Distance(zone, areas.AreaZone(i)) <= s_areaNear)
				{
					return true;
				}
			}
			return false;
		}

		private static int Distance(Vector2s a, Vector2s b)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return Math.Max(Math.Abs(a.x - b.x), Math.Abs(a.y - b.y));
		}

		private static int Key(Vector2s zone)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			return (zone.x << 16) | (ushort)zone.y;
		}

		private static Vector2s Unkey(int key)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2s((short)(key >> 16), (short)key);
		}
	}
	internal static class FarEnvironment
	{
		private sealed class Flash
		{
			public Light[] Lights;

			public Renderer[] Renderers;
		}

		private sealed class Shadow
		{
			public float Until;

			public EnvSetup Env;

			public Matrix4x4 ToFar;

			public Vector3 Place;

			public FollowPlayer Follower;

			public readonly List<Mover> Movers = new List<Mover>();

			public GameObject Go;

			public GameObject Original;

			public Place Owner;

			public ParticleSystem[] Systems;

			public bool Clone;

			public bool Wanted;

			public bool Fading;

			public float FadeUntil;
		}

		private sealed class Mover
		{
			public Transform T;

			public FollowPlayer Follower;

			public Vector3 Local;

			public readonly List<(ParticleSystem ps, ParticleSystemSimulationSpace space, Transform custom)> Systems = new List<(ParticleSystem, ParticleSystemSimulationSpace, Transform)>();
		}

		private sealed class Storm
		{
			public Thunder T;

			public Matrix4x4 ToFar;

			public EnvSetup Env;

			public float Until;

			public float NextAt;

			public float ThunderAt = -1f;

			public Vector3 FlashAt;

			public readonly List<GameObject> Flashes = new List<GameObject>();
		}

		private sealed class Place
		{
			public Vector3 At;

			public Matrix4x4 ToFar;

			public float SeenAt = -100f;

			public float CheckAt;

			public int Frame = -1;

			public long Period = long.MinValue;

			public bool Watched;

			public EnvSetup Override;

			public bool Sheltered;

			public EnvSetup Target;

			public EnvSetup From;

			public EnvSetup Mix;

			public EnvSetup MixFrom;

			public float BlendAt;

			public float T;

			public EnvSetup Systems;

			public bool Running;

			public bool Starting;

			public readonly List<Shadow> Shadows = new List<Shadow>();

			public Storm Storm;
		}

		private sealed class WeatherClone
		{
			public GameObject Original;

			public GameObject Go;

			public float FreeAt;
		}

		private static readonly FieldRef<EnvMan, EnvSetup> s_current = AccessTools.FieldRefAccess<EnvMan, EnvSetup>("m_currentEnv");

		private static readonly FieldRef<EnvMan, EnvSetup> s_next = AccessTools.FieldRefAccess<EnvMan, EnvSetup>("m_nextEnv");

		private static readonly FieldRef<EnvMan, string> s_forceEnv = AccessTools.FieldRefAccess<EnvMan, string>("m_forceEnv");

		private static readonly FieldRef<EnvMan, float> s_smoothDay = AccessTools.FieldRefAccess<EnvMan, float>("m_smoothDayFraction");

		private static readonly Func<EnvMan, List<EnvEntry>, EnvSetup> s_select = AccessTools.MethodDelegate<Func<EnvMan, List<EnvEntry>, EnvSetup>>(AccessTools.Method(typeof(EnvMan), "SelectWeightedEnvironment", (Type[])null, (Type[])null), (object)null, true);

		private static readonly Func<EnvMan, string, EnvSetup> s_getEnv = AccessTools.MethodDelegate<Func<EnvMan, string, EnvSetup>>(AccessTools.Method(typeof(EnvMan), "GetEnv", (Type[])null, (Type[])null), (object)null, true);

		private static readonly int s_skyboxSunDir = Shader.PropertyToID("_SkyboxSunDir");

		private static readonly int s_sunDir = Shader.PropertyToID("_SunDir");

		private static readonly int s_sunFogColor = Shader.PropertyToID("_SunFogColor");

		private static readonly int s_sunColor = Shader.PropertyToID("_SunColor");

		private static readonly int s_ambientColor = Shader.PropertyToID("_AmbientColor");

		private static readonly int s_wet = Shader.PropertyToID("_Wet");

		private static readonly int s_aurora = Shader.PropertyToID("_AuroraStrength");

		private static readonly int s_rain = Shader.PropertyToID("_Rain");

		private static readonly int s_opacity = Shader.PropertyToID("_Opacity");

		private static float s_day;

		private static float s_night;

		private static float s_morning;

		private static float s_evening;

		private static bool s_have;

		private static bool s_applied;

		private static Quaternion s_lightRot;

		private static float s_lightIntensity;

		private static Color s_lightColor;

		private static Color s_fogColor;

		private static Color s_ambient;

		private static Color s_sunFog;

		private static Color s_sunCol;

		private static Color s_ambientGlobal;

		private static float s_fogDensity;

		private static float s_wetValue;

		private static float s_auroraValue;

		private static float s_rainValue;

		private static float s_opacityValue;

		private static Vector4 s_skyDir;

		private static Vector4 s_sunDirValue;

		private static long s_cachePeriod = -1L;

		private static readonly Dictionary<Vector2s, EnvSetup> s_cache = new Dictionary<Vector2s, EnvSetup>();

		private static string s_forcedName;

		private static EnvSetup s_forcedEnv;

		internal static string LabLastPick = "";

		internal static string LabFarEnv;

		private static EnvSetup s_swapEnv;

		private static float s_labSetAt;

		internal static int LabSwaps;

		private static readonly FieldRef<EnvMan, GameObject[]> s_currentPSystems = AccessTools.FieldRefAccess<EnvMan, GameObject[]>("m_currentPSystems");

		private static readonly FieldRef<EnvMan, float> s_instantTimer = AccessTools.FieldRefAccess<EnvMan, float>("m_forceInstantEnvSwitchTimer");

		private static readonly List<Renderer> s_hidden = new List<Renderer>();

		private static readonly List<Renderer> s_shown = new List<Renderer>();

		private static readonly Dictionary<GameObject, Flash> s_flashParts = new Dictionary<GameObject, Flash>();

		private static readonly List<GameObject> s_flashDrop = new List<GameObject>();

		private static readonly FieldRef<EnvMan, GameObject> s_envObject = AccessTools.FieldRefAccess<EnvMan, GameObject>("m_currentEnvObject");

		private static readonly List<GameObject> s_flashes = new List<GameObject>();

		private static readonly List<Light> s_offLights = new List<Light>();

		internal static bool InStrike;

		private static readonly Dictionary<GameObject, Renderer[]> s_renderers = new Dictionary<GameObject, Renderer[]>();

		private static readonly int s_wind1 = Shader.PropertyToID("_GlobalWind1");

		private static readonly int s_wind2 = Shader.PropertyToID("_GlobalWind2");

		private static readonly int s_windForce = Shader.PropertyToID("_GlobalWindForce");

		private static Vector4 s_wind1Value;

		private static Vector4 s_wind2Value;

		private static Vector4 s_windForceValue;

		private static bool s_windSet;

		private static readonly Dictionary<GameObject, Shadow> s_shadow = new Dictionary<GameObject, Shadow>();

		private static readonly Dictionary<GameObject, (EnvSetup env, Matrix4x4 toFar, Vector3 place)> s_wanted = new Dictionary<GameObject, (EnvSetup, Matrix4x4, Vector3)>();

		private static readonly List<GameObject> s_drop = new List<GameObject>();

		private static readonly Dictionary<GlobalWind, GameObject[]> s_windChain = new Dictionary<GlobalWind, GameObject[]>();

		private static readonly List<GameObject> s_chainScratch = new List<GameObject>();

		private static readonly FieldRef<EnvMan, float> s_wetDuration = AccessTools.FieldRefAccess<EnvMan, float>("m_wetTransitionDuration");

		private static readonly List<(Vector3 place, float wet, float seenAt)> s_farWet = new List<(Vector3, float, float)>();

		private static readonly FieldInfo s_isWet = AccessTools.Field(typeof(EnvMan), "s_isWet");

		private static readonly FieldInfo s_isCold = AccessTools.Field(typeof(EnvMan), "s_isCold");

		private static readonly FieldInfo s_isFreezing = AccessTools.Field(typeof(EnvMan), "s_isFreezing");

		private static readonly Dictionary<Thunder, Storm> s_storms = new Dictionary<Thunder, Storm>();

		private static readonly List<Thunder> s_stormDrop = new List<Thunder>();

		private static readonly List<Light> s_onLights = new List<Light>();

		internal static int LabFarFlashes;

		internal static int LabFlashesShown;

		internal static int LabFarThunders;

		internal static EnvSetup Setting;

		private static readonly FieldRef<EnvMan, Vector4> s_windDir1 = AccessTools.FieldRefAccess<EnvMan, Vector4>("m_windDir1");

		private static readonly FieldRef<EnvMan, Vector4> s_windDir2 = AccessTools.FieldRefAccess<EnvMan, Vector4>("m_windDir2");

		private static readonly FieldRef<EnvMan, Vector4> s_windNow = AccessTools.FieldRefAccess<EnvMan, Vector4>("m_wind");

		private static readonly Action<EnvMan, float> s_updateWindTransition = AccessTools.MethodDelegate<Action<EnvMan, float>>(AccessTools.Method(typeof(EnvMan), "UpdateWindTransition", new Type[1] { typeof(float) }, (Type[])null), (object)null, true);

		internal static string LabLastSet = "";

		internal static string LabApplied;

		private static readonly Action<EnvMan, long, BiomeSector> s_updateEnvironment = AccessTools.MethodDelegate<Action<EnvMan, long, BiomeSector>>(AccessTools.Method(typeof(EnvMan), "UpdateEnvironment", new Type[2]
		{
			typeof(long),
			typeof(BiomeSector)
		}, (Type[])null), (object)null, true);

		private static readonly Func<EnvMan, BiomeSector> s_getBiome = AccessTools.MethodDelegate<Func<EnvMan, BiomeSector>>(AccessTools.Method(typeof(EnvMan), "GetBiome", Type.EmptyTypes, (Type[])null), (object)null, true);

		private static readonly Action<EnvMan, float> s_interpolate = AccessTools.MethodDelegate<Action<EnvMan, float>>(AccessTools.Method(typeof(EnvMan), "InterpolateEnvironment", new Type[1] { typeof(float) }, (Type[])null), (object)null, true);

		private static readonly Action<EnvMan, EnvSetup, float, float, float, float, float> s_setEnv = AccessTools.MethodDelegate<Action<EnvMan, EnvSetup, float, float, float, float, float>>(AccessTools.Method(typeof(EnvMan), "SetEnv", new Type[6]
		{
			typeof(EnvSetup),
			typeof(float),
			typeof(float),
			typeof(float),
			typeof(float),
			typeof(float)
		}, (Type[])null), (object)null, true);

		private static readonly List<Place> s_places = new List<Place>();

		private static readonly List<WeatherClone> s_clones = new List<WeatherClone>();

		private static readonly Dictionary<GameObject, bool> s_cloneable = new Dictionary<GameObject, bool>();

		private static readonly Dictionary<GameObject, Place> s_handTo = new Dictionary<GameObject, Place>();

		private static readonly Collider[] s_zoneHits = (Collider[])(object)new Collider[32];

		private static int s_placeStates;

		private static bool s_parityRuns;

		private static bool s_placeSwapped;

		private static Place s_swapPlace;

		private static EnvSetup s_swapKeyEnv;

		private const int MaxClones = 16;

		private const float CloneKeep = 300f;

		private const float FadeMax = 20f;

		private const int ChecksPerFrame = 2;

		private static int s_checkFrame = -1;

		private static int s_checks;

		private static bool s_overrideWarned;

		internal static int LabPlaceOverrides;

		internal static int LabPlaceSheltered;

		internal static long LabPlaceBlends;

		internal static long LabWeatherClones;

		private static readonly FieldRef<EnvMan, long> s_envPeriod = AccessTools.FieldRefAccess<EnvMan, long>("m_environmentPeriod");

		private static readonly FieldRef<RandEventSystem, RandomEvent> s_randomEvent = AccessTools.FieldRefAccess<RandEventSystem, RandomEvent>("m_randomEvent");

		private static readonly FieldRef<RandEventSystem, RandomEvent> s_forcedEvent = AccessTools.FieldRefAccess<RandEventSystem, RandomEvent>("m_forcedEvent");

		private static readonly int s_auroraCurrent = Shader.PropertyToID("_AuroraGradientCurrent");

		private static readonly int s_auroraNext = Shader.PropertyToID("_AuroraGradientNext");

		private static readonly int s_auroraBlend = Shader.PropertyToID("_AuroraGradientBlend");

		private static bool s_auroraSet;

		private static Texture s_auroraGameCur;

		private static Texture s_auroraGameNext;

		private static Texture s_auroraCur;

		private static Texture s_auroraNextNow;

		private static float s_auroraGameBlend;

		private static float s_auroraBlendNow;

		internal static bool HasFarState
		{
			get
			{
				if (s_shadow.Count <= 0 && s_storms.Count <= 0 && s_farWet.Count <= 0)
				{
					return s_places.Count > 0;
				}
				return true;
			}
		}

		internal static float DayFraction
		{
			get
			{
				if (!((Object)(object)EnvMan.instance != (Object)null))
				{
					return 0f;
				}
				return s_smoothDay.Invoke(EnvMan.instance);
			}
		}

		internal static EnvSetup Applied { get; private set; }

		internal static string GameEnvName
		{
			get
			{
				EnvMan instance = EnvMan.instance;
				return (((Object)(object)instance != (Object)null) ? s_current.Invoke(instance) : null)?.m_name;
			}
		}

		internal static bool OwnFlashing
		{
			get
			{
				for (int i = 0; i < s_flashes.Count; i++)
				{
					if ((Object)(object)s_flashes[i] != (Object)null)
					{
						return true;
					}
				}
				return false;
			}
		}

		internal static void Capture(float day, float night, float morning, float evening)
		{
			s_day = day;
			s_night = night;
			s_morning = morning;
			s_evening = evening;
			s_have = true;
		}

		internal static EnvSetup Pick(Vector3 pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return Pick(pos, places: true);
		}

		private static EnvSetup Pick(Vector3 pos, bool places, Place view = null)
		{
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			EnvMan instance = EnvMan.instance;
			if ((Object)(object)instance == (Object)null || WorldGenerator.instance == null || (Object)(object)ZNet.instance == (Object)null || instance.m_environmentDuration <= 0)
			{
				return null;
			}
			if (!string.IsNullOrEmpty(LabFarEnv))
			{
				EnvSetup val = s_getEnv(instance, LabFarEnv);
				EnvSetup val2 = s_current.Invoke(instance);
				if (val == null || (val2 != null && !(val2.m_name != val.m_name)))
				{
					return null;
				}
				return val;
			}
			bool weatherParity = FarFlags.WeatherParity;
			if (!weatherParity)
			{
				if (!string.IsNullOrEmpty(instance.m_debugEnv) || !string.IsNullOrEmpty(s_forceEnv.Invoke(instance)))
				{
					return null;
				}
			}
			else if (!string.IsNullOrEmpty(instance.m_debugEnv) || ((Object)(object)Player.m_localPlayer != (Object)null && ((Character)Player.m_localPlayer).InIntro()))
			{
				return null;
			}
			long period = (long)ZNet.instance.GetTimeSeconds() / instance.m_environmentDuration;
			EnvSetup val3 = ZonePick(instance, pos, period);
			if (!weatherParity)
			{
				EnvSetup val4 = s_current.Invoke(instance);
				if (val3 == null || (val4 != null && val4.m_name == val3.m_name && s_next.Invoke(instance) == null))
				{
					return null;
				}
				return val3;
			}
			Place place = ((places && s_placeStates > 0) ? (view ?? PlaceNear(pos)) : null);
			if (place != null && place.Override != null)
			{
				val3 = place.Override;
			}
			if (val3 == null)
			{
				return null;
			}
			if (place != null && place.From != null && place.Target == val3)
			{
				return val3;
			}
			bool forced;
			EnvSetup val5 = GameEnv(instance, out forced);
			if (val5 != null && val5.m_name == val3.m_name && (forced || s_next.Invoke(instance) == null))
			{
				return null;
			}
			return val3;
		}

		private static EnvSetup ZonePick(EnvMan em, Vector3 pos, long period)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			Vector2s zone = ZoneSystem.GetZone(pos);
			if (period != s_cachePeriod)
			{
				s_cachePeriod = period;
				s_cache.Clear();
			}
			if (!s_cache.TryGetValue(zone, out var value))
			{
				value = (s_cache[zone] = PickNow(em, pos, period));
			}
			return value;
		}

		private static EnvSetup GameEnv(EnvMan em, out bool forced)
		{
			string text = s_forceEnv.Invoke(em);
			forced = !string.IsNullOrEmpty(text);
			if (!forced)
			{
				return s_current.Invoke(em);
			}
			if ((object)text != s_forcedName)
			{
				s_forcedName = text;
				s_forcedEnv = s_getEnv(em, text);
			}
			return s_forcedEnv;
		}

		private static EnvSetup PickNow(EnvMan em, Vector3 pos, long period)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			EnvSetup val = PickNowInner(em, pos, period);
			LabLastPick = string.Format("{0} for {1} period {2}", (val != null) ? val.m_name : "none", WorldGenerator.instance.GetBiomeSector(pos, false).Biome, period);
			return val;
		}

		private static EnvSetup PickNowInner(EnvMan em, Vector3 pos, long period)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			BiomeSector biomeSector = WorldGenerator.instance.GetBiomeSector(pos, false);
			foreach (AltBiome altBiome in biomeSector.AltBiomes)
			{
				if (!string.IsNullOrEmpty(altBiome.m_forceEnvironment))
				{
					return s_getEnv(em, altBiome.m_forceEnvironment);
				}
			}
			bool flag = WorldGenerator.IsAshlands(pos.x, pos.z);
			bool flag2 = WorldGenerator.IsDeepnorth(pos.x, pos.y);
			State state = Random.state;
			Random.InitState((int)period);
			EnvSetup result = null;
			List<EnvEntry> availableEnvironments = em.GetAvailableEnvironments(biomeSector);
			if (availableEnvironments != null && availableEnvironments.Count > 0)
			{
				result = s_select(em, availableEnvironments);
				foreach (EnvEntry item in availableEnvironments)
				{
					if (item.m_ashlandsOverride && flag)
					{
						result = item.m_env;
					}
					if (item.m_deepnorthOverride && flag2)
					{
						result = item.m_env;
					}
				}
			}
			Random.state = state;
			return result;
		}

		internal static void Apply(Vector3 camPos)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (WindowFlags.EnvGroups && !s_applied)
			{
				ApplyGrouped(camPos);
			}
			else
			{
				ApplyOne(camPos);
			}
		}

		private static void ApplyOne(Vector3 camPos)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: 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_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			EnvMan instance = EnvMan.instance;
			if (s_applied || !s_have || (Object)(object)instance == (Object)null || (Object)(object)instance.m_dirLight == (Object)null)
			{
				return;
			}
			Place place = (FarFlags.WeatherParity ? ViewPlace(camPos) : null);
			EnvSetup val = Pick(camPos, places: true, place);
			if (val == null && (place == null || !PlaceDiffers(instance, place)))
			{
				return;
			}
			Light dirLight = instance.m_dirLight;
			s_applied = true;
			s_lightRot = ((Component)dirLight).transform.rotation;
			s_lightIntensity = dirLight.intensity;
			s_lightColor = dirLight.color;
			s_fogColor = RenderSettings.fogColor;
			s_fogDensity = RenderSettings.fogDensity;
			s_ambient = RenderSettings.ambientLight;
			s_skyDir = Shader.GetGlobalVector(s_skyboxSunDir);
			s_sunDirValue = Shader.GetGlobalVector(s_sunDir);
			s_sunFog = Shader.GetGlobalColor(s_sunFogColor);
			s_sunCol = Shader.GetGlobalColor(s_sunColor);
			s_ambientGlobal = Shader.GetGlobalColor(s_ambientColor);
			s_wetValue = Shader.GetGlobalFloat(s_wet);
			s_auroraValue = Shader.GetGlobalFloat(s_aurora);
			Material val2 = (((Object)(object)instance.m_clouds != (Object)null) ? ((Renderer)instance.m_clouds).sharedMaterial : null);
			if ((Object)(object)val2 != (Object)null)
			{
				s_rainValue = val2.GetFloat(s_rain);
				s_opacityValue = val2.GetFloat(s_opacity);
			}
			bool weatherParity = FarFlags.WeatherParity;
			if (val == null)
			{
				SwapPlace(instance, null, place);
				return;
			}
			EnvSetup val3 = (weatherParity ? LookOf(place, val) : val);
			Set(instance, val3, WetAt(place?.At ?? camPos, val));
			if (weatherParity)
			{
				Aurora(place, val);
			}
			LabApplied = val.m_name;
			Applied = val3;
			SetWind(instance, val3);
			if (weatherParity)
			{
				SwapPlace(instance, val, place);
			}
			else
			{
				SwapWeather(instance, val);
			}
		}

		private static void ApplyGrouped(Vector3 camPos)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			EnvMan instance = EnvMan.instance;
			if (!s_have || (Object)(object)instance == (Object)null || (Object)(object)instance.m_dirLight == (Object)null)
			{
				return;
			}
			bool weatherParity = FarFlags.WeatherParity;
			Place place = (weatherParity ? ViewPlace(camPos) : null);
			EnvSetup val = Pick(camPos, places: true, place);
			if (val == null)
			{
				AreaRenderState.ToGame(instance);
				AuroraBack();
				if (place != null && PlaceDiffers(instance, place))
				{
					if (!s_placeSwapped || s_swapPlace != place |