using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using VRShaderFix;
using VRShaderFix.utils;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("VRShaderFix")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Replaces All Materials to use VR Compatiable Shader Version")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("VRShaderFix")]
[assembly: AssemblyTitle("VRShaderFix")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public class ShaderFix : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <DelayedShaderFix>d__8 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public ShaderFix <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <DelayedShaderFix>d__8(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			int num = <>1__state;
			ShaderFix shaderFix = <>4__this;
			switch (num)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(1f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				Plugin.Logger.LogDebug((object)"Fixing Shaders");
				shaderFix.ReplaceMaterialsFor<Renderer>((IEnumerable<Renderer>)Resources.FindObjectsOfTypeAll<Renderer>());
				shaderFix.ReplaceMaterialsFor<SkinnedMeshRenderer>((IEnumerable<SkinnedMeshRenderer>)VRFixUtils.FindAllInLoadedScenes<SkinnedMeshRenderer>(Array.Empty<string>()));
				shaderFix.ReplaceMaterialsFor<ParticleSystemRenderer>((IEnumerable<ParticleSystemRenderer>)VRFixUtils.FindAllInLoadedScenes<ParticleSystemRenderer>(Array.Empty<string>()));
				shaderFix.ReplaceTerrainMaterials(Resources.FindObjectsOfTypeAll<Terrain>());
				shaderFix.LogMissingShaders();
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private static readonly Dictionary<string, Shader> BaseGameHDRPShaders = new Dictionary<string, Shader>(StringComparer.OrdinalIgnoreCase);

	private static readonly Dictionary<string, Shader> MissingShaders = new Dictionary<string, Shader>(StringComparer.OrdinalIgnoreCase);

	public Dictionary<string, Shader> CustomShaders = new Dictionary<string, Shader>(StringComparer.OrdinalIgnoreCase);

	public HashSet<string> CachedBlacklist { get; set; }

	public void StartShaderFix()
	{
		//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)
		if (Plugin.VRConfig.enableBlacklist.Value)
		{
			for (int i = 0; i < SceneManager.sceneCount; i++)
			{
				Scene sceneAt = SceneManager.GetSceneAt(i);
				if (CachedBlacklist.Contains(((Scene)(ref sceneAt)).name))
				{
					Plugin.Logger.LogWarning((object)("Skipped Applying VR Shader Fix to scene '" + ((Scene)(ref sceneAt)).name + "' because is blacklisted in Config"));
					return;
				}
			}
		}
		((MonoBehaviour)this).StartCoroutine(DelayedShaderFix());
	}

	[IteratorStateMachine(typeof(<DelayedShaderFix>d__8))]
	private IEnumerator DelayedShaderFix()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <DelayedShaderFix>d__8(0)
		{
			<>4__this = this
		};
	}

	private void ReplaceTerrainMaterials(IEnumerable<Terrain> terrains)
	{
		Dictionary<Material, Material> dictionary = new Dictionary<Material, Material>();
		foreach (Terrain terrain in terrains)
		{
			Material materialTemplate = terrain.materialTemplate;
			if (!IsValidOriginal(materialTemplate))
			{
				continue;
			}
			Shader val = ResolveShader(((Object)materialTemplate.shader).name);
			if ((Object)(object)val == (Object)null)
			{
				continue;
			}
			if (!dictionary.TryGetValue(materialTemplate, out var value))
			{
				value = CreateVRMaterial(materialTemplate, val);
				TerrainData terrainData = terrain.terrainData;
				TerrainLayer[] terrainLayers = terrainData.terrainLayers;
				value.shaderKeywords = materialTemplate.shaderKeywords;
				value.renderQueue = materialTemplate.renderQueue;
				value.SetInt("_LayerCount", terrainLayers.Length);
				for (int i = 0; i < terrainData.alphamapTextures.Length; i++)
				{
					value.SetTexture($"_Control{i}", (Texture)(object)terrainData.alphamapTextures[i]);
				}
				for (int j = 0; j < terrainLayers.Length; j++)
				{
					TerrainLayer val2 = terrainLayers[j];
					value.SetTexture($"_Splat{j}", (Texture)(object)val2.diffuseTexture);
					value.SetTexture($"_Normal{j}", (Texture)(object)val2.normalMapTexture);
					value.SetTexture($"_Mask{j}", (Texture)(object)val2.maskMapTexture);
				}
				dictionary[materialTemplate] = value;
			}
			terrain.materialTemplate = dictionary[materialTemplate];
			terrain.terrainData.terrainLayers = terrain.terrainData.terrainLayers;
			ForceDetailRefresh(terrain);
			terrain.terrainData.RefreshPrototypes();
			terrain.Flush();
		}
	}

	private Shader ResolveShader(string shaderName)
	{
		if (CustomShaders.TryGetValue(shaderName, out var value))
		{
			return value;
		}
		if (BaseGameHDRPShaders.TryGetValue(shaderName, out var value2))
		{
			return value2;
		}
		if (!MissingShaders.ContainsKey(shaderName))
		{
			MissingShaders.Add(shaderName, Shader.Find(shaderName));
		}
		return VRFixUtils.FindClosestShader(shaderName, CustomShaders) ?? VRFixUtils.FindClosestShader(shaderName, BaseGameHDRPShaders);
	}

	private Material CreateVRMaterial(Material original, Shader shader)
	{
		//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_001d: Expected O, but got Unknown
		Material val = new Material(shader)
		{
			name = ((Object)original).name + "_VR"
		};
		MaterialUtils.CopyMaterialProperties(original, val);
		return val;
	}

	private bool IsValidOriginal(Material mat)
	{
		if ((Object)(object)mat == (Object)null)
		{
			return false;
		}
		string name = ((Object)mat).name;
		int num = name.IndexOf(" (", StringComparison.Ordinal);
		return !((num >= 0) ? name.Substring(0, num) : name).Contains("_VR", StringComparison.OrdinalIgnoreCase);
	}

	private void LogMissingShaders()
	{
		if (!Plugin.VRConfig.enableDebug.Value)
		{
			return;
		}
		foreach (KeyValuePair<string, Shader> missingShader in MissingShaders)
		{
			Plugin.Logger.LogWarning((object)"-------------------");
			Plugin.Logger.LogError((object)("Missing VR Variant for Shader: " + ((Object)missingShader.Value).name));
		}
	}

	private void ReplaceMaterialsFor<TRenderer>(IEnumerable<TRenderer> renderers) where TRenderer : Renderer
	{
		Dictionary<Material, Material> dictionary = new Dictionary<Material, Material>();
		foreach (TRenderer renderer in renderers)
		{
			Material[] sharedMaterials = ((Renderer)renderer).sharedMaterials;
			if (sharedMaterials == null)
			{
				continue;
			}
			for (int i = 0; i < sharedMaterials.Length; i++)
			{
				Material val = sharedMaterials[i];
				if (!IsValidOriginal(val))
				{
					continue;
				}
				Shader val2 = ResolveShader(((Object)val.shader).name);
				if (!((Object)(object)val2 == (Object)null))
				{
					if (!dictionary.TryGetValue(val, out var value))
					{
						value = (dictionary[val] = CreateVRMaterial(val, val2));
					}
					sharedMaterials[i] = value;
				}
			}
			((Renderer)renderer).sharedMaterials = sharedMaterials;
			((Renderer)renderer).materials = sharedMaterials;
		}
	}

	public static void ForceDetailRefresh(Terrain terrain)
	{
		TerrainData terrainData = terrain.terrainData;
		typeof(TerrainData).GetMethod("RefreshPrototypes", BindingFlags.Instance | BindingFlags.NonPublic)?.Invoke(terrainData, null);
		for (int i = 0; i < terrainData.detailPrototypes.Length; i++)
		{
			int[,] detailLayer = terrainData.GetDetailLayer(0, 0, terrainData.detailWidth, terrainData.detailHeight, i);
			terrainData.SetDetailLayer(0, 0, i, detailLayer);
		}
	}

	public void CacheBaseGameShaders()
	{
		Plugin.Logger.LogInfo((object)"Scanning for base‑game HDRP + Shader Graph shaders...");
		Shader[] array = Resources.FindObjectsOfTypeAll<Shader>();
		foreach (Shader val in array)
		{
			if ((Object)(object)val == (Object)null)
			{
				continue;
			}
			string name = ((Object)val).name;
			bool num = name.StartsWith("HDRP/", StringComparison.OrdinalIgnoreCase);
			bool flag = name.StartsWith("Shader Graphs/", StringComparison.OrdinalIgnoreCase);
			if (!num && !flag)
			{
				continue;
			}
			int instanceID = ((Object)val).GetInstanceID();
			if (instanceID <= 0)
			{
				continue;
			}
			if (!BaseGameHDRPShaders.TryGetValue(name, out var value))
			{
				BaseGameHDRPShaders[name] = val;
				Plugin.Logger.LogInfo((object)$"Cached base‑game shader: {name} (ID {instanceID})");
				continue;
			}
			int instanceID2 = ((Object)value).GetInstanceID();
			if (instanceID2 <= 0 || instanceID < instanceID2)
			{
				BaseGameHDRPShaders[name] = val;
				Plugin.Logger.LogInfo((object)$"Updated base‑game shader: {name} → lower ID {instanceID} (was {instanceID2})");
			}
		}
		Plugin.Logger.LogInfo((object)$"Captured {BaseGameHDRPShaders.Count} base‑game shaders.");
	}
}
namespace VRShaderFix
{
	[HarmonyPatch]
	internal class Patches
	{
		[HarmonyPatch(typeof(RoundManager), "FinishGeneratingNewLevelClientRpc")]
		[HarmonyPostfix]
		public static void StartVRShaderFixViaPatch()
		{
			Plugin.Logger.LogDebug((object)"VR Shader Fix Applying");
			Plugin.ShaderFixHost.StartShaderFix();
			Plugin.Logger.LogDebug((object)"VR Shader Fix Applied");
		}

		[HarmonyPatch(typeof(StartOfRound), "OnShipLandedMiscEvents")]
		[HarmonyPostfix]
		public static void StartVRShaderFixViaPatchBackup2()
		{
			Plugin.Logger.LogDebug((object)"VR Shader Fix Backup Call");
			Plugin.ShaderFixHost.StartShaderFix();
			Plugin.Logger.LogDebug((object)"VR Shader Fix Backup Call End");
		}
	}
	[BepInPlugin("TKronix.VRShaderFix", "VRShaderFix", "1.0.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		private const string GUID = "TKronix.VRShaderFix";

		private const string NAME = "VRShaderFix";

		private const string VERSION = "1.0.0.0";

		private static int PressCount;

		internal static ManualLogSource Logger { get; private set; }

		public static ShaderFix ShaderFixHost { get; private set; }

		internal static VRSFConfig VRConfig { get; private set; }

		private void Awake()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"Plugin loading");
			VRConfig = new VRSFConfig(((BaseUnityPlugin)this).Config);
			InputAction val = new InputAction("RunVRShaderFix", (InputActionType)1, "<Keyboard>/f1", (string)null, (string)null, (string)null);
			InputAction val2 = new InputAction("RunVRShaderFix2", (InputActionType)1, "<Keyboard>/f2", (string)null, (string)null, (string)null);
			val.performed += delegate
			{
				ShaderFixHost.StartShaderFix();
			};
			val2.performed += delegate
			{
				Hotkey2();
			};
			val.Disable();
			val2.Disable();
			if (VRConfig.enableDebug.Value)
			{
				val.Enable();
				val2.Enable();
			}
			SceneManager.sceneLoaded += InitalizeVRShaderFix;
			if (VRConfig.enableHarmonyPatches.Value)
			{
				new Harmony("TKronix.VRShaderFix").PatchAll(typeof(Patches));
				Logger.LogInfo((object)"Plugin Harmony Patches Applied!");
			}
			Logger.LogInfo((object)"Plugin loaded!");
		}

		private void InitalizeVRShaderFix(Scene scene, LoadSceneMode mode)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			if (!((Scene)(ref scene)).name.Equals("SampleSceneRelay", StringComparison.OrdinalIgnoreCase))
			{
				return;
			}
			GameObject val = new GameObject("VRShaderFixHost");
			Object.DontDestroyOnLoad((Object)val);
			ShaderFixHost = val.AddComponent<ShaderFix>();
			ShaderFixHost.CacheBaseGameShaders();
			AssetBundle val2 = LoadAssetBundle("vrmaterials");
			Material[] array = val2.LoadAllAssets<Material>();
			foreach (Material val3 in array)
			{
				if (!((Object)(object)val3 == (Object)null))
				{
					Logger.LogInfo((object)("Loaded Material: " + ((Object)val3).name));
					ShaderFixHost.CustomShaders.Add(((Object)val3.shader).name, val3.shader);
				}
			}
			ShaderFixHost.CachedBlacklist = (from s in VRConfig.blacklistedScenes.Value.Split(',')
				select s.Trim() into s
				where !string.IsNullOrEmpty(s)
				select s).ToHashSet<string>(StringComparer.OrdinalIgnoreCase);
			val2.Unload(false);
			val2 = null;
			SceneManager.sceneLoaded -= InitalizeVRShaderFix;
			SceneManager.sceneLoaded += ApplyVRFixOnSceneLoad;
			ShaderFixHost.StartShaderFix();
		}

		private void CheckScene(Scene scene, LoadSceneMode mode)
		{
			if (((Scene)(ref scene)).name.Equals("SampleSceneRelay", StringComparison.OrdinalIgnoreCase))
			{
				SceneManager.sceneLoaded += ApplyVRFixOnSceneLoad;
				SceneManager.sceneLoaded -= CheckScene;
			}
		}

		private void ApplyVRFixOnSceneLoad(Scene scene, LoadSceneMode mode)
		{
			if (VRConfig.enableLogSceneToConsole.Value)
			{
				string text = "Use name below for Blacklisting";
				string name = ((Scene)(ref scene)).name;
				int num = Mathf.Max(text.Length, name.Length) + 6;
				string text2 = "╔" + new string('═', num) + "╗";
				string text3 = "║" + Center(text, num) + "║";
				string text4 = "║" + Center(name, num) + "║";
				string text5 = "╚" + new string('═', num) + "╝";
				Logger.LogInfo((object)text2);
				Logger.LogInfo((object)text3);
				Logger.LogInfo((object)text4);
				Logger.LogInfo((object)text5);
			}
			if (((Scene)(ref scene)).name.Equals("MainMenu", StringComparison.OrdinalIgnoreCase))
			{
				SceneManager.sceneLoaded -= ApplyVRFixOnSceneLoad;
				SceneManager.sceneLoaded += CheckScene;
			}
			else
			{
				ShaderFixHost.StartShaderFix();
			}
		}

		private string Center(string text, int totalWidth)
		{
			int num = totalWidth - text.Length;
			int num2 = num / 2;
			int count = num - num2;
			return new string(' ', num2) + text + new string(' ', count);
		}

		private AssetBundle LoadAssetBundle(string AssetBundle)
		{
			return AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), AssetBundle));
		}

		private static void Hotkey2()
		{
			PressCount++;
			if (PressCount == 1)
			{
				Object.FindObjectOfType<PreInitSceneScript>().ChooseLaunchOption(true);
			}
			if (PressCount == 2)
			{
				Object.FindObjectOfType<MenuManager>().StartHosting();
			}
			if (PressCount == 3)
			{
				StartOfRound.Instance.ChangeLevel(17);
			}
			if (PressCount == 4)
			{
				Object.FindObjectOfType<StartMatchLever>().StartGame();
			}
		}
	}
	internal class VRSFConfig
	{
		public readonly ConfigEntry<bool> enableBlacklist;

		public readonly ConfigEntry<bool> enableLogSceneToConsole;

		public readonly ConfigEntry<string> blacklistedScenes;

		public readonly ConfigEntry<bool> enableHarmonyPatches;

		public readonly ConfigEntry<bool> enableDebug;

		public VRSFConfig(ConfigFile cfg)
		{
			enableLogSceneToConsole = cfg.Bind<bool>("Blacklist", "EnableLogSceneNameToConsole", false, "Enable or disable Logging of Scene Name to Console");
			enableBlacklist = cfg.Bind<bool>("Blacklist", "EnableBlacklist", false, "Enable or disable the scene blacklist system");
			blacklistedScenes = cfg.Bind<string>("Blacklist", "BlacklistedScenes", "ExampleSceneName1, ExampleSceneName2", "List of scene names to NOT replace shaders/materials on.\n(Separated by commas)");
			enableHarmonyPatches = cfg.Bind<bool>("HarmonyPatches", "EnableHarmonyPatches", true, "Enable or disable the Harmony Patches");
			enableDebug = cfg.Bind<bool>("Development", "EnableDevelopmentFeatures", false, "Enable or disable Dvelopment features \n(Ignore this its for Development Purposes Only nothing useful for Gameplay)");
		}
	}
}
namespace VRShaderFix.utils
{
	public static class MaterialUtils
	{
		public static void CopyMaterialProperties(Material source, Material target)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected I4, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)source == (Object)null || (Object)(object)target == (Object)null)
			{
				return;
			}
			target.renderQueue = source.renderQueue;
			target.globalIlluminationFlags = source.globalIlluminationFlags;
			CopyShaderKeywords(source, target);
			Shader shader = source.shader;
			int propertyCount = shader.GetPropertyCount();
			for (int i = 0; i < propertyCount; i++)
			{
				string propertyName = shader.GetPropertyName(i);
				ShaderPropertyType propertyType = shader.GetPropertyType(i);
				if (!target.HasProperty(propertyName))
				{
					continue;
				}
				switch ((int)propertyType)
				{
				case 0:
					target.SetColor(propertyName, source.GetColor(propertyName));
					break;
				case 1:
					target.SetVector(propertyName, source.GetVector(propertyName));
					break;
				case 2:
				case 3:
					target.SetFloat(propertyName, source.GetFloat(propertyName));
					break;
				case 4:
				{
					Texture texture = source.GetTexture(propertyName);
					target.SetTexture(propertyName, texture);
					if ((Object)(object)texture != (Object)null)
					{
						target.SetTextureOffset(propertyName, source.GetTextureOffset(propertyName));
						target.SetTextureScale(propertyName, source.GetTextureScale(propertyName));
					}
					break;
				}
				}
			}
			CopyMainTextureShortcuts(source, target);
		}

		private static void CopyShaderKeywords(Material source, Material target)
		{
			HashSet<string> hashSet = new HashSet<string>(source.shaderKeywords);
			string[] shaderKeywords = target.shaderKeywords;
			foreach (string item in shaderKeywords)
			{
				hashSet.Add(item);
			}
			target.shaderKeywords = hashSet.ToArray();
		}

		private static void CopyMainTextureShortcuts(Material source, Material target)
		{
			//IL_001c: 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)
			if (target.HasProperty("_MainTex"))
			{
				target.mainTexture = source.mainTexture;
				target.mainTextureOffset = source.mainTextureOffset;
				target.mainTextureScale = source.mainTextureScale;
			}
		}
	}
	public static class VRFixUtils
	{
		private static readonly string[] DefaultExcludedScenes = new string[3] { "MainMenu", "DontDestroyOnLoad", "HideAndDontSave" };

		public static List<T> FindAllInLoadedScenes<T>(params string[] excludedScenes) where T : Component
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (excludedScenes == null || excludedScenes.Length == 0)
			{
				excludedScenes = DefaultExcludedScenes;
			}
			List<T> list = new List<T>();
			int sceneCount = SceneManager.sceneCount;
			for (int i = 0; i < sceneCount; i++)
			{
				Scene sceneAt = SceneManager.GetSceneAt(i);
				if (((Scene)(ref sceneAt)).isLoaded && !excludedScenes.Contains(((Scene)(ref sceneAt)).name))
				{
					GameObject[] rootGameObjects = ((Scene)(ref sceneAt)).GetRootGameObjects();
					foreach (GameObject val in rootGameObjects)
					{
						list.AddRange(val.GetComponentsInChildren<T>(true));
					}
				}
			}
			return list;
		}

		public static Shader FindClosestShader(string name, Dictionary<string, Shader> shaders)
		{
			Shader result = null;
			int num = -1;
			foreach (KeyValuePair<string, Shader> shader in shaders)
			{
				string key = shader.Key;
				if ((key.StartsWith(name, StringComparison.OrdinalIgnoreCase) || name.StartsWith(key, StringComparison.OrdinalIgnoreCase)) && key.Length > num)
				{
					num = key.Length;
					result = shader.Value;
				}
			}
			return result;
		}
	}
}