using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using GameData;
using Gear;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Reflection;
using Microsoft.CodeAnalysis;
using Player;
using ReTFO.ThermalOverlay.Config;
using ReTFO.ThermalOverlay.Configurers;
using ReTFO.ThermalOverlay.Factories;
using ReTFO.ThermalOverlay.Interfaces;
using SNetwork;
using UnityEngine;
using UnityEngine.Rendering;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("ThermalOverlay")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+c9e8a15a79a69ffca0739a38ec89a5278201cf10")]
[assembly: AssemblyProduct("ThermalOverlay")]
[assembly: AssemblyTitle("ThermalOverlay")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace ReTFO.ThermalOverlay
{
	public class AssetBundle
	{
		public const string AssetBundleName = "thermaloverlay";

		private Shader? _thermalOverlayShader;

		public static string AssetDirectory => Path.Combine(Path.GetDirectoryName(Paths.PluginPath) ?? string.Empty, "Assets");

		public static string AssetBundlePath => Path.Combine(AssetDirectory, "ThermalOverlay", "thermaloverlay");

		public Shader? ThermalOverlayShader
		{
			get
			{
				return _thermalOverlayShader ?? (_thermalOverlayShader = this.TryLoadAsset<Shader>("Unlit_HolographicSight_ThermalOverlay.shader"));
			}
			set
			{
				_thermalOverlayShader = value ?? _thermalOverlayShader;
			}
		}

		public T? TryLoadAsset<T>(string assetName) where T : Object
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Expected O, but got Unknown
			AssetBundle val = AssetBundle.LoadFromFile(AssetBundlePath);
			bool flag = default(bool);
			if ((Object)(object)val == (Object)null)
			{
				Plugin plugin = Plugin.TryGet();
				Plugin plugin2 = plugin;
				if (plugin2 != null)
				{
					ManualLogSource log = ((BasePlugin)plugin2).Log;
					BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(53, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Failed to load asset bundle ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("thermaloverlay");
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("\n - Expected location: \"");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(AssetBundlePath);
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("\"");
					}
					log.LogError(val2);
				}
				return default(T);
			}
			Object val3 = (Object)(object)((val != null) ? val.LoadAsset(assetName) : null);
			if (val3 == null)
			{
				Plugin plugin3 = Plugin.TryGet();
				if (plugin3 != null)
				{
					ManualLogSource log2 = ((BasePlugin)plugin3).Log;
					BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(34, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Failed to load ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(assetName);
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" from asset bundle ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("thermaloverlay");
					}
					log2.LogError(val2);
				}
			}
			T val4 = ((val3 != null) ? ((Il2CppObjectBase)val3).TryCast<T>() : default(T));
			if (val4 == null && val3 != null)
			{
				Plugin plugin4 = Plugin.TryGet();
				if (plugin4 != null)
				{
					ManualLogSource log3 = ((BasePlugin)plugin4).Log;
					BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(50, 3, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Failed to convert ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(assetName);
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" to type ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(typeof(T).Name);
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" because it is of type ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(((MemberInfo)val3.GetIl2CppType()).Name);
					}
					log3.LogError(val2);
				}
			}
			return val4;
		}

		public bool TryLoadAsset<T>(string assetName, [NotNullWhen(true)] out T? result) where T : Object
		{
			result = TryLoadAsset<T>(assetName);
			return result != null;
		}

		public T LoadAsset<T>(string assetName) where T : Object
		{
			return TryLoadAsset<T>(assetName) ?? throw new NullReferenceException("Failed to load asset " + assetName);
		}
	}
	public class Il2CppAction : Object
	{
		private Action? _action;

		public Il2CppAction(Action action)
			: base(ClassInjector.DerivedConstructorPointer<Il2CppAction>())
		{
			ClassInjector.DerivedConstructorBody((Il2CppObjectBase)(object)this);
			_action = action;
		}

		public Il2CppAction(IntPtr pointer)
			: base(pointer)
		{
		}

		public void Action()
		{
			if (_action != null)
			{
				_action();
			}
		}

		public static implicit operator Action(Il2CppAction self)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			IntPtr il2CppMethod = IL2CPP.GetIl2CppMethod(((Il2CppObjectBase)self).ObjectClass, false, "Action", "System.Void", Array.Empty<string>());
			return new Action((Object)(object)self, il2CppMethod);
		}
	}
	[HarmonyPatch(typeof(PlayerBackpack))]
	internal static class ItemSpawnPatcher
	{
		[HarmonyPatch("CheckAndCreateBackpackItem")]
		[HarmonyPostfix]
		internal static void OnCreate(PlayerBackpack __instance, ref BackpackItem bpItem, ItemEquippable gearItem, GearIDRange gearIDRange)
		{
			Plugin.Get().OnItemCreated(gearItem, __instance.Owner);
		}
	}
	[BepInPlugin("RoboRyGuy.ThermalOverlay", "ThermalOverlay", "1.3.2")]
	[BepInProcess("GTFO.exe")]
	public class Plugin : BasePlugin
	{
		public const string Name = "ThermalOverlay";

		public const string Author = "RoboRyGuy";

		public const string GUID = "RoboRyGuy.ThermalOverlay";

		public const string Version = "1.3.2";

		private static Plugin? _plugin;

		protected Harmony harmony = new Harmony("RoboRyGuy.ThermalOverlay");

		public const string OverlayGameObjectName = "Thermal Overlay";

		public AssetBundle AssetBundle { get; private set; } = new AssetBundle();


		public ConfigManager ConfigManager { get; private set; } = new ConfigManager();


		public FactoryManager FactoryManager { get; private set; } = new FactoryManager();


		public static Plugin Get()
		{
			return TryGet() ?? throw new NullReferenceException("Tried to retrieve ThermalOverlay, but it was not loaded!");
		}

		public static Plugin? TryGet()
		{
			return _plugin ?? (_plugin = ((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.FirstOrDefault((KeyValuePair<string, PluginInfo> p) => p.Key == "RoboRyGuy.ThermalOverlay").Value.Instance as Plugin);
		}

		public static bool TryGet([NotNullWhen(true)] out Plugin? plugin)
		{
			plugin = TryGet();
			return plugin != null;
		}

		public override void Load()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			_plugin = this;
			harmony.PatchAll(typeof(ItemSpawnPatcher));
			harmony.PatchAll(((object)this).GetType());
			ClassInjector.RegisterTypeInIl2Cpp(typeof(Il2CppAction));
			ManualLogSource log = ((BasePlugin)this).Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(11, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("RoboRyGuy.ThermalOverlay");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" is loaded!");
			}
			log.LogInfo(val);
		}

		public override bool Unload()
		{
			harmony.UnpatchSelf();
			return true;
		}

		public void SetItemNames(ICollection<string> itemNames)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			if (ConfigManager.TryGetUserConfigs(out UserConfigs _))
			{
				ManualLogSource log = ((BasePlugin)this).Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(94, 0, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Changing item names after config file is generated; the config description will be inaccurate!");
				}
				log.LogWarning(val);
			}
			ConfigManager.ItemNames = itemNames;
		}

		public void OnItemCreated(ItemEquippable item, SNet_Player owner)
		{
			ItemEquippable item2 = item;
			SNet_Player owner2 = owner;
			if (!item2.m_gearSpawnComplete)
			{
				item2.GearPartHolder.m_gearPartSpawner.OnAllPartsSpawned += new Il2CppAction(delegate
				{
					ApplyConfig(item2, owner2.IsLocal);
				});
			}
		}

		public void ApplyConfig(ItemEquippable item, bool isLocal)
		{
			string publicGearName = item.GearIDRange.PublicGearName;
			if (!ConfigManager.IsIDEnabled(publicGearName))
			{
				return;
			}
			ThermalConfig config = ConfigManager.GetConfig(publicGearName);
			ConversionContext context = new ConversionContext(this, item, config);
			FactoryManager.RunThermalConverter(config?.Handler, context);
			if (!(ConfigManager.UserConfigs.MakeGunsCold && isLocal))
			{
				return;
			}
			foreach (Renderer componentsInChild in ((Component)item).GetComponentsInChildren<Renderer>())
			{
				if (componentsInChild.sharedMaterial.HasProperty("_ShadingType"))
				{
					componentsInChild.sharedMaterial.SetFloat("_ShadingType", 0f);
				}
			}
		}
	}
	public class Quaternion_JsonConverter : JsonConverter<Quaternion>
	{
		public override void Write(Utf8JsonWriter writer, Quaternion value, JsonSerializerOptions options)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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)
			writer.WriteStartObject();
			writer.WriteNumber("x", value.x);
			writer.WriteNumber("y", value.y);
			writer.WriteNumber("z", value.z);
			writer.WriteNumber("w", value.w);
			writer.WriteEndObject();
		}

		public override Quaternion Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
		{
			//IL_0016: 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)
			if (reader.TokenType != JsonTokenType.StartObject)
			{
				throw new JsonException("Expected StartObject token");
			}
			Quaternion result = default(Quaternion);
			while (reader.Read())
			{
				if (reader.TokenType == JsonTokenType.EndObject)
				{
					return result;
				}
				if (reader.TokenType != JsonTokenType.PropertyName)
				{
					throw new JsonException("Expected PropertyName token");
				}
				string @string = reader.GetString();
				reader.Read();
				switch (@string)
				{
				case "x":
					result.x = reader.GetSingle();
					break;
				case "y":
					result.y = reader.GetSingle();
					break;
				case "z":
					result.z = reader.GetSingle();
					break;
				case "w":
					result.w = reader.GetSingle();
					break;
				default:
					reader.Skip();
					break;
				}
			}
			throw new JsonException("Incomplete Vector4 object");
		}
	}
	public class Vector2_JsonConverter : JsonConverter<Vector2>
	{
		public override void Write(Utf8JsonWriter writer, Vector2 value, JsonSerializerOptions options)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			writer.WriteStartObject();
			writer.WriteNumber("x", value.x);
			writer.WriteNumber("y", value.y);
			writer.WriteEndObject();
		}

		public override Vector2 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (reader.TokenType != JsonTokenType.StartObject)
			{
				throw new JsonException("Expected StartObject token");
			}
			Vector2 result = default(Vector2);
			while (reader.Read())
			{
				if (reader.TokenType == JsonTokenType.EndObject)
				{
					return result;
				}
				if (reader.TokenType != JsonTokenType.PropertyName)
				{
					throw new JsonException("Expected PropertyName token");
				}
				string @string = reader.GetString();
				reader.Read();
				if (!(@string == "x"))
				{
					if (@string == "y")
					{
						result.y = reader.GetSingle();
					}
					else
					{
						reader.Skip();
					}
				}
				else
				{
					result.x = reader.GetSingle();
				}
			}
			throw new JsonException("Incomplete Vector2 object");
		}
	}
	public class Vector3_JsonConverter : JsonConverter<Vector3>
	{
		public override void Write(Utf8JsonWriter writer, Vector3 value, JsonSerializerOptions options)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			writer.WriteStartObject();
			writer.WriteNumber("x", value.x);
			writer.WriteNumber("y", value.y);
			writer.WriteNumber("z", value.z);
			writer.WriteEndObject();
		}

		public override Vector3 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
		{
			//IL_0016: 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)
			if (reader.TokenType != JsonTokenType.StartObject)
			{
				throw new JsonException("Expected StartObject token");
			}
			Vector3 result = default(Vector3);
			while (reader.Read())
			{
				if (reader.TokenType == JsonTokenType.EndObject)
				{
					return result;
				}
				if (reader.TokenType != JsonTokenType.PropertyName)
				{
					throw new JsonException("Expected PropertyName token");
				}
				string @string = reader.GetString();
				reader.Read();
				switch (@string)
				{
				case "x":
					result.x = reader.GetSingle();
					break;
				case "y":
					result.y = reader.GetSingle();
					break;
				case "z":
					result.z = reader.GetSingle();
					break;
				default:
					reader.Skip();
					break;
				}
			}
			throw new JsonException("Incomplete Vector3 object");
		}
	}
	public class Vector4_JsonConverter : JsonConverter<Vector4>
	{
		public override void Write(Utf8JsonWriter writer, Vector4 value, JsonSerializerOptions options)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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)
			writer.WriteStartObject();
			writer.WriteNumber("x", value.x);
			writer.WriteNumber("y", value.y);
			writer.WriteNumber("z", value.z);
			writer.WriteNumber("w", value.w);
			writer.WriteEndObject();
		}

		public override Vector4 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
		{
			//IL_0016: 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)
			if (reader.TokenType != JsonTokenType.StartObject)
			{
				throw new JsonException("Expected StartObject token");
			}
			Vector4 result = default(Vector4);
			while (reader.Read())
			{
				if (reader.TokenType == JsonTokenType.EndObject)
				{
					return result;
				}
				if (reader.TokenType != JsonTokenType.PropertyName)
				{
					throw new JsonException("Expected PropertyName token");
				}
				string @string = reader.GetString();
				reader.Read();
				switch (@string)
				{
				case "x":
					result.x = reader.GetSingle();
					break;
				case "y":
					result.y = reader.GetSingle();
					break;
				case "z":
					result.z = reader.GetSingle();
					break;
				case "w":
					result.w = reader.GetSingle();
					break;
				default:
					reader.Skip();
					break;
				}
			}
			throw new JsonException("Incomplete Vector4 object");
		}
	}
}
namespace ReTFO.ThermalOverlay.Interfaces
{
	public interface IMaterialGenerator
	{
		Material GenerateMaterial(string? thisName, ConversionContext context);
	}
	public interface IMeshGenerator
	{
		Mesh GenerateMesh(string? thisName, ConversionContext context);
	}
	public interface IOverlayGenerator
	{
		bool GenerateOverlay(string? thisName, ConversionContext context);
	}
	public interface ISightConverter
	{
		bool ConvertSight(string? thisName, ConversionContext context);
	}
	public interface ITextureGenerator
	{
		Texture GenerateTexture(string? thisName, ConversionContext context);
	}
	public interface IThermalConverter
	{
		void ConvertItem(string? thisName, ConversionContext context);
	}
}
namespace ReTFO.ThermalOverlay.Configurers
{
	public class ThermalConverter_Auto : IThermalConverter
	{
		public const string Name = "Auto";

		public virtual void ConvertItem(string? thisName, ConversionContext context)
		{
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Expected O, but got Unknown
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Expected O, but got Unknown
			//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fd: Expected O, but got Unknown
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a1: Expected O, but got Unknown
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Expected O, but got Unknown
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Expected O, but got Unknown
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Expected O, but got Unknown
			Renderer val = null;
			if (context.Item.GearPartHolder.SightData != null)
			{
				GameObject sightPart = context.Item.GearPartHolder.SightPart;
				val = ((sightPart != null) ? ((IEnumerable<Renderer>)sightPart.GetComponentsInChildren<Renderer>()).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => r.sharedMaterial.HasProperty("_ReticuleA"))) : null);
			}
			else if ((Object)(object)context.Item.GearPartHolder.ToolScreenPart != (Object)null)
			{
				GameObject sightPart2 = context.Item.GearPartHolder.SightPart;
				val = ((sightPart2 != null) ? ((IEnumerable<Renderer>)sightPart2.GetComponentsInChildren<Renderer>()).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r.sharedMaterial.shader).name == "Cell/Player/Display_GearShader")) : null);
			}
			bool flag = true;
			bool flag2 = true;
			string[] parameters = FactoryManager.GetParameters(thisName);
			bool flag3 = default(bool);
			if (parameters.Length != 0)
			{
				string text = parameters[0];
				if (text.Length != 0)
				{
					switch (text)
					{
					case "SightOnly":
						flag2 = false;
						break;
					case "OverlayOnly":
						flag = false;
						break;
					case "AllowNone":
						flag = false;
						flag2 = false;
						break;
					default:
					{
						ManualLogSource log = context.Log;
						BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(137, 1, ref flag3);
						if (flag3)
						{
							((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("ThermalConverter_Auto expected one of { \"AllowAll\", \"OverlayOnly\", \"SightOnly\", \"AllowNone\" } for its first parameter, but instead got \"");
							((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(text);
							((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("\"");
						}
						log.LogError(val2);
						break;
					}
					case "AllowAll":
						break;
					}
				}
			}
			if (parameters.Length > 1)
			{
				ManualLogSource log2 = context.Log;
				BepInExWarningLogInterpolatedStringHandler val3 = new BepInExWarningLogInterpolatedStringHandler(49, 1, ref flag3);
				if (flag3)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("ThermalConverter_Auto ignoring extra parameters: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(FactoryManager.FormatParams(parameters[1..]));
				}
				log2.LogWarning(val3);
			}
			bool flag4 = false;
			if ((Object)(object)val != (Object)null && flag)
			{
				context.Renderer = val;
				Shader thermalOverlayShader = context.Plugin.AssetBundle.ThermalOverlayShader;
				if ((Object)(object)thermalOverlayShader == (Object)null)
				{
					ManualLogSource log3 = context.Log;
					BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(67, 0, ref flag3);
					if (flag3)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("ThermalConverter_Auto failed; could not load thermal overlay shader");
					}
					log3.LogError(val2);
					return;
				}
				if (((IEnumerable<Material>)context.Renderer.sharedMaterials).Select((Material m) => m.shader).Contains(thermalOverlayShader))
				{
					ManualLogSource log4 = context.Log;
					BepInExDebugLogInterpolatedStringHandler val4 = new BepInExDebugLogInterpolatedStringHandler(73, 1, ref flag3);
					if (flag3)
					{
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral("Skipping sight conversion on item \"");
						((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<string>(((Object)context.Item).name);
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral("\" due to sight already being converted");
					}
					log4.LogDebug(val4);
					return;
				}
				bool flag5 = ((Object)val.sharedMaterial.shader).name.Contains("thermal", StringComparison.OrdinalIgnoreCase);
				flag4 = context.Plugin.FactoryManager.RunSightConverter(context.Config?.SightConverter, context);
			}
			if (!flag4 && flag2)
			{
				Transform obj = ((Component)context.Item).transform.Find("Thermal Overlay");
				GameObject val5 = ((obj != null) ? ((Component)obj).gameObject : null);
				if ((Object)(object)val5 != (Object)null)
				{
					ManualLogSource log5 = context.Log;
					BepInExDebugLogInterpolatedStringHandler val4 = new BepInExDebugLogInterpolatedStringHandler(73, 1, ref flag3);
					if (flag3)
					{
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral("Skipping overlay creation on item \"");
						((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<string>(((Object)context.Item).name);
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral("\" due to overlay already being created");
					}
					log5.LogDebug(val4);
					return;
				}
				flag4 = context.Factory.RunOverlayGenerator(context.Config?.OverlayGenerator, context);
			}
			if (flag4)
			{
				if ((Object)(object)context.Material == (Object)null)
				{
					ManualLogSource log6 = context.Log;
					BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(93, 0, ref flag3);
					if (flag3)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Error: A converter or generator has failed to set the material property for ConversionContext");
					}
					log6.LogError(val2);
				}
				else
				{
					FactoryManager.CalcScopeCenter(context);
					ApplyCleanScope(context);
					context.Config?.MaterialConfig.ApplyAll(context.Material, context);
				}
			}
			else
			{
				ManualLogSource log7 = context.Log;
				BepInExWarningLogInterpolatedStringHandler val3 = new BepInExWarningLogInterpolatedStringHandler(62, 1, ref flag3);
				if (flag3)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("ThermalConverter_Auto: conversion ended in failure for item \"");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(((Object)context.Item).name);
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("\"");
				}
				log7.LogWarning(val3);
			}
		}

		public static void ApplyCleanScope(ConversionContext context)
		{
			if ((Object)(object)context.Material == (Object)null)
			{
				context.Log.LogError((object)"Cannot ApplyCleanScope when the scope has no material");
			}
			else if (((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.Any((KeyValuePair<string, PluginInfo> p) => p.Key.Contains("CleanScopes")))
			{
				context.Material.SetFloat("_SightDirt", 0f);
			}
		}
	}
}
namespace ReTFO.ThermalOverlay.Factories
{
	public class ConversionContext
	{
		public Plugin Plugin;

		public ItemEquippable Item;

		public Renderer? Renderer;

		public Material? Material;

		public ThermalConfig? Config;

		public ManualLogSource Log => ((BasePlugin)Plugin).Log;

		public FactoryManager Factory => Plugin.FactoryManager;

		public ConversionContext(Plugin plugin, ItemEquippable item)
		{
			Plugin = plugin;
			Item = item;
		}

		public ConversionContext(Plugin plugin, ItemEquippable item, ThermalConfig? config)
		{
			Plugin = plugin;
			Item = item;
			Config = config;
		}
	}
	public class FactoryManager
	{
		private SortedList<string, IThermalConverter> thermalConverters = new SortedList<string, IThermalConverter>();

		private int defaultThermalConverter = -1;

		private SortedList<string, ISightConverter> sightConverters = new SortedList<string, ISightConverter>();

		private int defaultSightConverter = -1;

		private SortedList<string, IOverlayGenerator> overlayGenerators = new SortedList<string, IOverlayGenerator>();

		private int defaultoverlayGenerator = -1;

		private SortedList<string, IMeshGenerator> meshGenerators = new SortedList<string, IMeshGenerator>();

		private int defaultMeshGenerator = -1;

		private SortedList<string, IMaterialGenerator> materialGenerators = new SortedList<string, IMaterialGenerator>();

		private int defaultMaterialGenerator = -1;

		private SortedList<string, ITextureGenerator> textureGenerators = new SortedList<string, ITextureGenerator>();

		private int defaultTextureGenerator = -1;

		public FactoryManager()
		{
			AddThermalConverter("Auto", new ThermalConverter_Auto(), makeDefault: true);
			AddSightConverter("Standard", new SightConverter_Standard(), makeDefault: true);
			AddOverlayGenerator("Standard", new OverlayGenerator_Standard(), makeDefault: true);
			AddOverlayGenerator("Load", new OverlayGenerator_Load());
			AddMaterialGenerator("PDW", new MaterialGenerator_PDW());
			AddMaterialGenerator("PR", new MaterialGenerator_PR());
			AddMaterialGenerator("Load", new MaterialGenerator_Load());
			AddMaterialGenerator("Auto", new MaterialGenerator_Auto(), makeDefault: true);
			AddMeshGenerator("Plane", new MeshGenerator_Plane());
			AddMeshGenerator("Diamond", new MeshGenerator_Diamond(), makeDefault: true);
			AddTextureGenerator("black", new TextureGenerator_Simple(() => (Texture)(object)Texture2D.blackTexture));
			AddTextureGenerator("gray", new TextureGenerator_Simple(() => (Texture)(object)Texture2D.grayTexture));
			AddTextureGenerator("linearGray", new TextureGenerator_Simple(() => (Texture)(object)Texture2D.linearGrayTexture));
			AddTextureGenerator("normal", new TextureGenerator_Simple(() => (Texture)(object)Texture2D.normalTexture));
			AddTextureGenerator("red", new TextureGenerator_Simple(() => (Texture)(object)Texture2D.redTexture));
			AddTextureGenerator("white", new TextureGenerator_Simple(() => (Texture)(object)Texture2D.whiteTexture));
			AddTextureGenerator("Load", new TextureGenerator_Load());
			AddTextureGenerator("Bloom", new TextureGenerator_Bloom(), makeDefault: true);
		}

		public static string? BaseName(string? name)
		{
			int num = name?.IndexOf('(') ?? (-1);
			return num switch
			{
				-1 => name, 
				0 => null, 
				_ => name.Substring(0, num), 
			};
		}

		public static string[] GetParameters(string? name)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			if (name == null)
			{
				return Array.Empty<string>();
			}
			int num = name.IndexOf('(');
			if (num < 0)
			{
				return Array.Empty<string>();
			}
			if (name.Last() != ')')
			{
				ManualLogSource log = ((BasePlugin)Plugin.Get()).Log;
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(39, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Expected ')' at end of texture name: '");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("'");
				}
				log.LogError(val);
				return (from s in name.Substring(num + 1).Split(',')
					select s.Trim()).ToArray();
			}
			return (from s in name.Substring(num + 1, name.Length - num - 2).Split(',')
				select s.Trim()).ToArray();
		}

		public static string FormatParams(string[]? paras)
		{
			if (paras == null)
			{
				return "\"<null>\"";
			}
			return "\"" + string.Join(", ", paras) + "\"";
		}

		public static bool TryCalcScopeCenter(ConversionContext context)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			Renderer renderer = context.Renderer;
			if ((Object)(object)renderer == (Object)null)
			{
				return false;
			}
			if ((Object)(object)context.Material == (Object)null)
			{
				return false;
			}
			Vector3 val = ((Component)renderer).transform.InverseTransformPoint(context.Item.SightLookAlign.position);
			Vector4 val2 = default(Vector4);
			val2.x = val.x;
			val2.y = val.y;
			val2.z = val.z;
			val2.w = 1f;
			Vector4 val3 = val2;
			context.Material.SetVector("_ScopeCenter", val3);
			return true;
		}

		public static void CalcScopeCenter(ConversionContext context)
		{
			if (!TryCalcScopeCenter(context))
			{
				if ((Object)(object)context.Renderer == (Object)null && (Object)(object)context.Material == (Object)null)
				{
					throw new NullReferenceException("CalcScopeCenter was passed null parameters: Renderer and Material");
				}
				if ((Object)(object)context.Renderer == (Object)null)
				{
					throw new NullReferenceException("CalcScopeCenter was passed a null parameter: Renderer");
				}
				if ((Object)(object)context.Material == (Object)null)
				{
					throw new NullReferenceException("CalcScopeCenter was passed a null parameter: Material");
				}
				throw new NullReferenceException("CalcScopeCenter encountered an unknown issue");
			}
		}

		public void AddThermalConverter(string name, IThermalConverter converter, bool makeDefault = false)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			name = BaseName(name);
			if (thermalConverters.ContainsKey(name))
			{
				Plugin plugin = Plugin.TryGet();
				if (plugin != null)
				{
					ManualLogSource log = ((BasePlugin)plugin).Log;
					bool flag = default(bool);
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(37, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Overwriting ThermalConvert \"");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\" with \"");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(converter.GetType().Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
					}
					log.LogWarning(val);
				}
			}
			thermalConverters[name] = converter;
			int num = thermalConverters.IndexOfKey(name);
			if (makeDefault)
			{
				defaultThermalConverter = num;
			}
			else if (num <= defaultThermalConverter)
			{
				defaultThermalConverter++;
			}
		}

		public IThermalConverter GetDefaultThermalConverter()
		{
			return thermalConverters.ElementAt(defaultThermalConverter).Value;
		}

		public bool TryGetThermalConverter(string? name, out IThermalConverter converter)
		{
			int num = ((name != null) ? thermalConverters.IndexOfKey(BaseName(name)) : (-1));
			if (num >= 0)
			{
				converter = thermalConverters.ElementAt(num).Value;
			}
			else
			{
				converter = GetDefaultThermalConverter();
			}
			return num >= 0;
		}

		public IThermalConverter GetThermalConverter(string? name)
		{
			TryGetThermalConverter(name, out IThermalConverter converter);
			return converter;
		}

		public void RunThermalConverter(string? name, ConversionContext context)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			if (!TryGetThermalConverter(name, out IThermalConverter converter) && name != null)
			{
				ManualLogSource log = context.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(55, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Failed to find thermal converter \"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\", using default (\"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(converter.GetType().Name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\")");
				}
				log.LogWarning(val);
			}
			converter.ConvertItem(name, context);
		}

		public void AddSightConverter(string name, ISightConverter converter, bool makeDefault = false)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			name = BaseName(name);
			if (sightConverters.ContainsKey(name))
			{
				Plugin plugin = Plugin.TryGet();
				if (plugin != null)
				{
					ManualLogSource log = ((BasePlugin)plugin).Log;
					bool flag = default(bool);
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(37, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Overwriting SightConverter \"");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\" with \"");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(converter.GetType().Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
					}
					log.LogWarning(val);
				}
			}
			sightConverters[name] = converter;
			int num = sightConverters.IndexOfKey(name);
			if (makeDefault)
			{
				defaultSightConverter = num;
			}
			else if (num <= defaultSightConverter)
			{
				defaultSightConverter++;
			}
		}

		public ISightConverter GetDefaultSightConverter()
		{
			return sightConverters.ElementAt(defaultSightConverter).Value;
		}

		public bool TryGetSightConverter(string? name, out ISightConverter converter)
		{
			int num = ((name != null) ? sightConverters.IndexOfKey(BaseName(name)) : (-1));
			if (num >= 0)
			{
				converter = sightConverters.ElementAt(num).Value;
			}
			else
			{
				converter = GetDefaultSightConverter();
			}
			return num >= 0;
		}

		public ISightConverter GetSightConverter(string? name)
		{
			TryGetSightConverter(name, out ISightConverter converter);
			return converter;
		}

		public bool RunSightConverter(string? name, ConversionContext context)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			if (!TryGetSightConverter(name, out ISightConverter converter) && name != null)
			{
				ManualLogSource log = context.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(53, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Failed to find sight converter \"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\", using default (\"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(converter.GetType().Name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\")");
				}
				log.LogWarning(val);
			}
			return converter.ConvertSight(name, context);
		}

		public void AddOverlayGenerator(string name, IOverlayGenerator generator, bool makeDefault = false)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			name = BaseName(name);
			if (overlayGenerators.ContainsKey(name))
			{
				Plugin plugin = Plugin.TryGet();
				if (plugin != null)
				{
					ManualLogSource log = ((BasePlugin)plugin).Log;
					bool flag = default(bool);
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(39, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Overwriting OverlayGenerator \"");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\" with \"");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(generator.GetType().Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
					}
					log.LogWarning(val);
				}
			}
			overlayGenerators[name] = generator;
			int num = overlayGenerators.IndexOfKey(name);
			if (makeDefault)
			{
				defaultoverlayGenerator = num;
			}
			else if (num <= defaultoverlayGenerator)
			{
				defaultoverlayGenerator++;
			}
		}

		public IOverlayGenerator GetDefaultOverlayGenerator()
		{
			return overlayGenerators.ElementAt(defaultoverlayGenerator).Value;
		}

		public bool TryGetOverlayGenerator(string? name, out IOverlayGenerator converter)
		{
			int num = ((name != null) ? overlayGenerators.IndexOfKey(BaseName(name)) : (-1));
			if (num >= 0)
			{
				converter = overlayGenerators.ElementAt(num).Value;
			}
			else
			{
				converter = GetDefaultOverlayGenerator();
			}
			return num >= 0;
		}

		public IOverlayGenerator GetOverlayGenerator(string? name)
		{
			TryGetOverlayGenerator(name, out IOverlayGenerator converter);
			return converter;
		}

		public bool RunOverlayGenerator(string? name, ConversionContext context)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			if (!TryGetOverlayGenerator(name, out IOverlayGenerator converter) && name != null)
			{
				ManualLogSource log = context.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(55, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Failed to find overlay generator \"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\", using default (\"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(converter.GetType().Name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\")");
				}
				log.LogWarning(val);
			}
			return converter.GenerateOverlay(name, context);
		}

		public void AddMeshGenerator(string name, IMeshGenerator generator, bool makeDefault = false)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			name = BaseName(name);
			if (meshGenerators.ContainsKey(name))
			{
				Plugin plugin = Plugin.TryGet();
				if (plugin != null)
				{
					ManualLogSource log = ((BasePlugin)plugin).Log;
					bool flag = default(bool);
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(36, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Overwriting MeshGenerator \"");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\" with \"");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(generator.GetType().Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
					}
					log.LogWarning(val);
				}
			}
			meshGenerators[name] = generator;
			int num = meshGenerators.IndexOfKey(name);
			if (makeDefault)
			{
				defaultMeshGenerator = num;
			}
			else if (num <= defaultMeshGenerator)
			{
				defaultMeshGenerator++;
			}
		}

		public IMeshGenerator GetDefaultMeshGenerator()
		{
			return meshGenerators.ElementAt(defaultMeshGenerator).Value;
		}

		public bool TryGetMeshGenerator(string? name, out IMeshGenerator generator)
		{
			int num = ((name != null) ? meshGenerators.IndexOfKey(BaseName(name)) : (-1));
			if (num >= 0)
			{
				generator = meshGenerators.ElementAt(num).Value;
			}
			else
			{
				generator = GetDefaultMeshGenerator();
			}
			return num >= 0;
		}

		public IMeshGenerator GetMeshGenerator(string? name)
		{
			TryGetMeshGenerator(name, out IMeshGenerator generator);
			return generator;
		}

		public Mesh RunMeshGenerator(string? name, ConversionContext context)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			if (!TryGetMeshGenerator(name, out IMeshGenerator generator) && name != null)
			{
				ManualLogSource log = context.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(52, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Failed to find mesh generator \"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\", using default (\"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(generator.GetType().Name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\")");
				}
				log.LogWarning(val);
			}
			return generator.GenerateMesh(name, context);
		}

		public void AddMaterialGenerator(string name, IMaterialGenerator generator, bool makeDefault = false)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			name = BaseName(name);
			if (materialGenerators.ContainsKey(name))
			{
				Plugin plugin = Plugin.TryGet();
				if (plugin != null)
				{
					ManualLogSource log = ((BasePlugin)plugin).Log;
					bool flag = default(bool);
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(40, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Overwriting MaterialGenerator \"");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\" with \"");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(generator.GetType().Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
					}
					log.LogWarning(val);
				}
			}
			materialGenerators[name] = generator;
			int num = materialGenerators.IndexOfKey(name);
			if (makeDefault)
			{
				defaultMaterialGenerator = num;
			}
			else if (num <= defaultMaterialGenerator)
			{
				defaultMaterialGenerator++;
			}
		}

		public IMaterialGenerator GetDefaultMaterialGenerator()
		{
			return materialGenerators.ElementAt(defaultMaterialGenerator).Value;
		}

		public bool TryGetMaterialGenerator(string? name, out IMaterialGenerator generator)
		{
			int num = ((name != null) ? materialGenerators.IndexOfKey(BaseName(name)) : (-1));
			if (num >= 0)
			{
				generator = materialGenerators.ElementAt(num).Value;
			}
			else
			{
				generator = GetDefaultMaterialGenerator();
			}
			return num >= 0;
		}

		public IMaterialGenerator GetMaterialGenerator(string? name)
		{
			TryGetMaterialGenerator(name, out IMaterialGenerator generator);
			return generator;
		}

		public Material RunMaterialGenerator(string? name, ConversionContext context)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			if (!TryGetMaterialGenerator(name, out IMaterialGenerator generator) && name != null)
			{
				ManualLogSource log = context.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(56, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Failed to find material generator \"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\", using default (\"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(generator.GetType().Name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\")");
				}
				log.LogWarning(val);
			}
			return generator.GenerateMaterial(name, context);
		}

		public void AddTextureGenerator(string name, ITextureGenerator generator, bool makeDefault = false)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			name = BaseName(name);
			if (textureGenerators.ContainsKey(name))
			{
				Plugin plugin = Plugin.TryGet();
				if (plugin != null)
				{
					ManualLogSource log = ((BasePlugin)plugin).Log;
					bool flag = default(bool);
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(39, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Overwriting TextureGenerator \"");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\" with \"");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(generator.GetType().Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
					}
					log.LogWarning(val);
				}
			}
			textureGenerators[name] = generator;
			int num = textureGenerators.IndexOfKey(name);
			if (makeDefault)
			{
				defaultTextureGenerator = num;
			}
			else if (num <= defaultTextureGenerator)
			{
				defaultTextureGenerator++;
			}
		}

		public ITextureGenerator GetDefaultTextureGenerator()
		{
			return textureGenerators.ElementAt(defaultTextureGenerator).Value;
		}

		public bool TryGetTextureGenerator(string? name, out ITextureGenerator generator)
		{
			int num = ((name != null) ? textureGenerators.IndexOfKey(BaseName(name)) : (-1));
			if (num >= 0)
			{
				generator = textureGenerators.ElementAt(num).Value;
			}
			else
			{
				generator = GetDefaultTextureGenerator();
			}
			return num >= 0;
		}

		public ITextureGenerator GetTextureGenerator(string? name)
		{
			TryGetTextureGenerator(name, out ITextureGenerator generator);
			return generator;
		}

		public Texture RunTextureGenerator(string? name, ConversionContext context)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			if (!TryGetTextureGenerator(name, out ITextureGenerator generator) && name != null)
			{
				ManualLogSource log = context.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(55, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Failed to find texture generator \"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\", using default (\"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(generator.GetType().Name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\")");
				}
				log.LogWarning(val);
			}
			return generator.GenerateTexture(name, context);
		}
	}
	public class MaterialGenerator_Auto : IMaterialGenerator
	{
		public const string Name = "Auto";

		public static readonly List<string> ThermalTextures = new List<string> { "rainbow.png", "Thremal_Gradient_FLIR.png", "blackhot.png", "lava.png", "whitehot.png", "Thremal_Gradient_EVIL.png" };

		public virtual Material GenerateMaterial(string? thisName, ConversionContext context)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: 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_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Expected O, but got Unknown
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Expected O, but got Unknown
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Expected O, but got Unknown
			Shader thermalOverlayShader = context.Plugin.AssetBundle.ThermalOverlayShader;
			if ((Object)(object)thermalOverlayShader == (Object)null)
			{
				context.Log.LogError((object)"SightConverter_Standard failed; failed to load thermal shader");
				return new Material(Shader.Find("Hidden/InternalErrorShader"));
			}
			ArchetypeDataBlock archetypeData = context.Item.ArchetypeData;
			float num = Vector2.Dot((Vector2)((archetypeData != null) ? archetypeData.DamageFalloff : new Vector2(0f, 0f)), new Vector2(0.5f, 0.5f));
			bool flag = true;
			bool flag2 = num <= 45f;
			string[] parameters = FactoryManager.GetParameters(thisName);
			bool flag3 = default(bool);
			if (parameters.Length != 0)
			{
				string text = parameters[0];
				if (text.Length != 0)
				{
					if (text == "Transparent")
					{
						flag = true;
					}
					else if (text == "Opaque")
					{
						flag = false;
					}
					else
					{
						ManualLogSource log = context.Log;
						BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(108, 1, ref flag3);
						if (flag3)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("MaterialGenerator_Auto expected either \"Transparent\" or \"Opaque\" for its first parameter, but instead got \"");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
						}
						log.LogError(val);
					}
				}
			}
			if (parameters.Length > 1)
			{
				string text2 = parameters[1];
				if (text2.Length != 0)
				{
					if (text2 == "PDW")
					{
						flag2 = true;
					}
					else if (text2 == "PR")
					{
						flag2 = false;
					}
					else
					{
						ManualLogSource log2 = context.Log;
						BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(97, 1, ref flag3);
						if (flag3)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("MaterialGenerator_Auto expected either \"PDW\" or \"PR\" for its second parameter, but instead got \"");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text2);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
						}
						log2.LogError(val);
					}
				}
			}
			if (parameters.Length > 2)
			{
				ManualLogSource log3 = context.Log;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(50, 1, ref flag3);
				if (flag3)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("MaterialGenerator_Auto ignoring extra parameters: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(FactoryManager.FormatParams(parameters[2..]));
				}
				log3.LogWarning(val2);
			}
			Material val3 = new Material(thermalOverlayShader)
			{
				name = $"ThermalOverlay - Auto ({(flag ? "Transparent" : "Opaque")}, {(flag2 ? "PDW" : "PR")})",
				hideFlags = (HideFlags)61
			};
			MaterialConfig materialConfig = ((!flag2) ? MaterialGenerator_PR.PRMaterialConfig.Clone() : MaterialGenerator_PDW.PDWMaterialConfig.Clone());
			int num2 = ((GameDataBlockBase<GearSightPartDataBlock>)(object)context.Item.GearPartHolder.SightData)?.persistentID.GetHashCode() ?? context.Item.GearIDRange.GetChecksum().GetHashCode();
			num2 = Mathf.Abs(num2 % ThermalTextures.Count);
			materialConfig.HeatTex = "Load(ThermalOverlay, " + ThermalTextures[num2] + ")";
			if (flag)
			{
				materialConfig.HeatTex = materialConfig.HeatTex.Value.Replace(".png", "_Transparent.png");
				materialConfig.AmbientTemp = 0.01f;
				materialConfig.BackgroundTemp = 0.01f;
			}
			materialConfig.Zoom = 0f;
			materialConfig.OffAngleFade = 0f;
			materialConfig.ApplyAllWithDefaults(val3, context);
			return val3;
		}
	}
	public class MaterialGenerator_Load : IMaterialGenerator
	{
		public const string Name = "Load";

		public static string GameDataPath => Path.Combine(Path.GetDirectoryName(Paths.PluginPath) ?? "", "GameData");

		public Material GenerateMaterial(string? thisName, ConversionContext context)
		{
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Expected O, but got Unknown
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Expected O, but got Unknown
			Shader thermalOverlayShader = context.Plugin.AssetBundle.ThermalOverlayShader;
			if ((Object)(object)thermalOverlayShader == (Object)null)
			{
				context.Log.LogError((object)"Failed to generate material; overlay shader failed to load");
				return new Material(Shader.Find("Hidden/InternalErrorShader"));
			}
			string[] parameters = FactoryManager.GetParameters(thisName);
			bool flag = default(bool);
			if (parameters.Length == 0)
			{
				ManualLogSource log = context.Log;
				BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(86, 0, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("MaterialGenerator_Load expected a file path in its parameters, but instead got nothing");
				}
				log.LogDebug(val);
				return new Material(Shader.Find("Hidden/InternalErrorShader"));
			}
			string text = Path.Combine(parameters);
			string text2 = Path.Combine(GameDataPath, text);
			BepInExErrorLogInterpolatedStringHandler val2;
			if (File.Exists(text2))
			{
				string json = File.ReadAllText(text2);
				MaterialConfig materialConfig;
				try
				{
					materialConfig = JsonSerializer.Deserialize<MaterialConfig>(json);
				}
				catch (JsonException)
				{
					ManualLogSource log2 = context.Log;
					val2 = new BepInExErrorLogInterpolatedStringHandler(73, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("MaterialGenerator_Load failed to deserialize material config from file \"");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(text);
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("\"");
					}
					log2.LogError(val2);
					throw;
				}
				Material val3 = new Material(thermalOverlayShader)
				{
					name = "Thermal Overlay - " + text,
					hideFlags = (HideFlags)61
				};
				materialConfig.ApplyAllWithDefaults(val3, context);
				return val3;
			}
			ManualLogSource log3 = context.Log;
			val2 = new BepInExErrorLogInterpolatedStringHandler(88, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("MaterialGenerator_Load failed to load file; file not found\n - File name: ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(text);
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("\n - Full path: ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(text2);
			}
			log3.LogError(val2);
			return new Material(Shader.Find("Hidden/InternalErrorShader"));
		}
	}
	public class MaterialGenerator_PDW : IMaterialGenerator
	{
		public const string Name = "PDW";

		public static readonly MaterialConfig PDWMaterialConfig = new MaterialConfig
		{
			Zoom = 0.25f,
			ScreenIntensity = 0.1f,
			HeatTex = "Load(ThermalOverlay, Thremal_Gradient_FLIR.png)",
			HeatFalloff = 0.03f,
			FogFalloff = 0.7f,
			AlbedoColorFactor = 0.1f,
			OcclusionHeat = 0.25f,
			BodyOcclusionHeat = 1f,
			DistortionTex = "Load(ThermalOverlay, Scanline.png)",
			DistortionSpeed = 3f,
			DistortionSignal = "Load(ThermalOverlay, ThermalDistortionSignal.png)",
			DistortionSignalSpeed = 0.025f,
			DistortionMin = 0.1f,
			DistortionMinShadowEnemies = 0.3f,
			DistortionMaxShadowEnemies = 0.9f,
			DistortionSignalSpeedShadowEnemies = 0.05f,
			ShadowEnemyFresnel = 50f,
			ShadowEnemyHeat = 0.6f,
			MainTex = "red",
			FPSRenderingEnabled = true
		};

		public virtual Material GenerateMaterial(string? thisName, ConversionContext context)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			Shader thermalOverlayShader = context.Plugin.AssetBundle.ThermalOverlayShader;
			if ((Object)(object)thermalOverlayShader == (Object)null)
			{
				context.Log.LogError((object)"Failed to generate material; overlay shader failed to load");
				return new Material(Shader.Find("Hidden/InternalErrorShader"));
			}
			bool flag = true;
			string[] parameters = FactoryManager.GetParameters(thisName);
			bool flag2 = default(bool);
			if (parameters.Length != 0)
			{
				string text = parameters[0];
				if (text.Length != 0)
				{
					if (text == "Transparent")
					{
						flag = true;
					}
					else if (text == "Opaque")
					{
						flag = false;
					}
					else
					{
						ManualLogSource log = context.Log;
						BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(86, 1, ref flag2);
						if (flag2)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("MaterialGenerator_PDW passed bad first parameter: ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral(", expected \"Transparent\" or \"Opaque\"");
						}
						log.LogError(val);
					}
				}
			}
			if (parameters.Length > 1)
			{
				ManualLogSource log2 = context.Log;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(49, 1, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("MaterialGenerator_PDW ignoring extra parameters: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(FactoryManager.FormatParams(parameters[1..]));
				}
				log2.LogWarning(val2);
			}
			Material val3 = new Material(thermalOverlayShader)
			{
				name = "ThermalOverlay - PDW (" + (flag ? "Transparent" : "Opaque") + ")",
				hideFlags = (HideFlags)61
			};
			MaterialConfig materialConfig = PDWMaterialConfig.Clone();
			if (flag)
			{
				materialConfig.HeatTex = materialConfig.HeatTex.Value.Replace(".png", "_Transparent.png");
				materialConfig.AmbientTemp = 0.01f;
				materialConfig.BackgroundTemp = 0.01f;
			}
			materialConfig.Zoom = 0f;
			materialConfig.OffAngleFade = 0f;
			materialConfig.ApplyAllWithDefaults(val3, context);
			return val3;
		}
	}
	public class MaterialGenerator_PR : IMaterialGenerator
	{
		public const string Name = "PR";

		public static readonly MaterialConfig PRMaterialConfig = new MaterialConfig
		{
			Zoom = 0.25f,
			RatioAdjust = 0.89f,
			ScreenIntensity = 0.152f,
			HeatTex = "Load(ThermalOverlay, Thremal_Gradient_EVIL.png)",
			HeatFalloff = 0.01f,
			FogFalloff = 0.5f,
			BackgroundTemp = 0f,
			AmbientColorFactor = 5f,
			AlbedoColorFactor = 0.5f,
			AmbientTemp = 0.15f,
			OcclusionHeat = 0.25f,
			BodyOcclusionHeat = 1f,
			DistortionTex = "Load(ThermalOverlay, Scanline.png)",
			DistortionScale = 1f,
			DistortionSpeed = 1f,
			DistortionSignal = "Load(ThermalOverlay, ThermalDistortionSignal.png)",
			DistortionSignalSpeed = 0.025f,
			DistortionMin = 0.1f,
			DistortionMax = 0.4f,
			DistortionMinShadowEnemies = 0.3f,
			DistortionMaxShadowEnemies = 0.9f,
			DistortionSignalSpeedShadowEnemies = 0.05f,
			ShadowEnemyFresnel = 50f,
			ShadowEnemyHeat = 0.6f,
			MainTex = "red",
			FPSRenderingEnabled = true
		};

		public virtual Material GenerateMaterial(string? thisName, ConversionContext context)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			Shader thermalOverlayShader = context.Plugin.AssetBundle.ThermalOverlayShader;
			if ((Object)(object)thermalOverlayShader == (Object)null)
			{
				context.Log.LogError((object)"Failed to generate material; overlay shader failed to load");
				return new Material(Shader.Find("Hidden/InternalErrorShader"));
			}
			bool flag = true;
			string[] parameters = FactoryManager.GetParameters(thisName);
			bool flag2 = default(bool);
			if (parameters.Length != 0)
			{
				string text = parameters[0];
				if (text.Length != 0)
				{
					if (text == "Transparent")
					{
						flag = true;
					}
					else if (text == "Opaque")
					{
						flag = false;
					}
					else
					{
						ManualLogSource log = context.Log;
						BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(85, 1, ref flag2);
						if (flag2)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("MaterialGenerator_PR passed bad first parameter: ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral(", expected \"Transparent\" or \"Opaque\"");
						}
						log.LogError(val);
					}
				}
			}
			if (parameters.Length > 1)
			{
				ManualLogSource log2 = context.Log;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(48, 1, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("MaterialGenerator_PR ignoring extra parameters: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(FactoryManager.FormatParams(parameters[1..]));
				}
				log2.LogWarning(val2);
			}
			Material val3 = new Material(thermalOverlayShader)
			{
				name = "ThermalOverlay - PR (" + (flag ? "Transparent" : "Opaque") + ")",
				hideFlags = (HideFlags)61
			};
			MaterialConfig materialConfig = PRMaterialConfig.Clone();
			if (flag)
			{
				materialConfig.HeatTex = materialConfig.HeatTex.Value.Replace(".png", "_Transparent.png");
				materialConfig.AmbientTemp = 0.01f;
				materialConfig.BackgroundTemp = 0.01f;
			}
			materialConfig.Zoom = 0f;
			materialConfig.OffAngleFade = 0f;
			materialConfig.ApplyAllWithDefaults(val3, context);
			return val3;
		}
	}
	public class MeshGenerator_Diamond : IMeshGenerator
	{
		public const string Name = "Diamond";

		public virtual Mesh GenerateMesh(string? thisName, ConversionContext context)
		{
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Expected O, but got Unknown
			//IL_015a: 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_0171: 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_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: 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_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			float num = 0.05f;
			float num2 = 0.5f;
			string[] parameters = FactoryManager.GetParameters(thisName);
			bool flag = default(bool);
			if (parameters.Length != 0)
			{
				string text = parameters[0];
				if (text.Length != 0)
				{
					if (float.TryParse(text, out var result))
					{
						num *= result;
					}
					else
					{
						ManualLogSource log = context.Log;
						BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(82, 1, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("MeshGenerator_Diamond expected a float for its first parameter, but instead got \"");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
						}
						log.LogError(val);
					}
				}
			}
			if (parameters.Length > 1)
			{
				string text2 = parameters[1];
				if (text2.Length != 0)
				{
					if (float.TryParse(text2, out var result2))
					{
						num2 = result2;
					}
					else
					{
						ManualLogSource log2 = context.Log;
						BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(83, 1, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("MeshGenerator_Diamond expected a float for its second parameter, but instead got \"");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text2);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
						}
						log2.LogError(val);
					}
				}
			}
			if (parameters.Length > 2)
			{
				ManualLogSource log3 = context.Log;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(49, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("MeshGenerator_Diamond ignoring extra parameters: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(FactoryManager.FormatParams(parameters[2..]));
				}
				log3.LogWarning(val2);
			}
			Mesh val3 = new Mesh();
			((Object)val3).name = "Diamond (Generated)";
			val3.vertices = Il2CppStructArray<Vector3>.op_Implicit((Vector3[])(object)new Vector3[5]
			{
				new Vector3(0f, 0f, (0f - num) * num2),
				new Vector3(0f, num, 0f),
				new Vector3(num, 0f, 0f),
				new Vector3(0f, 0f - num, 0f),
				new Vector3(0f - num, 0f, 0f)
			});
			val3.uv = Il2CppStructArray<Vector2>.op_Implicit((Vector2[])(object)new Vector2[5]
			{
				new Vector2(0.5f, 0.5f),
				new Vector2(0f, 1f),
				new Vector2(0f, 0f),
				new Vector2(1f, 0f),
				new Vector2(1f, 1f)
			});
			val3.normals = Il2CppStructArray<Vector3>.op_Implicit((Vector3[])(object)new Vector3[5]
			{
				new Vector3(0f, 0f, -1f),
				new Vector3(0f, 0f, -1f),
				new Vector3(0f, 0f, -1f),
				new Vector3(0f, 0f, -1f),
				new Vector3(0f, 0f, -1f)
			});
			val3.triangles = Il2CppStructArray<int>.op_Implicit(new int[12]
			{
				0, 1, 2, 0, 2, 3, 0, 3, 4, 0,
				4, 1
			});
			Mesh val4 = val3;
			val4.RecalculateTangents();
			return val4;
		}
	}
	public class MeshGenerator_Plane : IMeshGenerator
	{
		public const string Name = "Plane";

		public virtual Mesh GenerateMesh(string? thisName, ConversionContext context)
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			float num = 0.035f;
			string[] parameters = FactoryManager.GetParameters(thisName);
			bool flag = default(bool);
			if (parameters.Length != 0)
			{
				string text = parameters[0];
				if (text.Length != 0)
				{
					if (float.TryParse(text, out var result))
					{
						num *= result;
					}
					else
					{
						ManualLogSource log = context.Log;
						BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(80, 1, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("MeshGenerator_Plane expected a float for its first parameter, but instead got \"");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
						}
						log.LogError(val);
					}
				}
			}
			if (parameters.Length > 1)
			{
				ManualLogSource log2 = context.Log;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(47, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("MeshGenerator_Plane ignoring extra parameters: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(FactoryManager.FormatParams(parameters[1..]));
				}
				log2.LogWarning(val2);
			}
			Mesh val3 = new Mesh();
			((Object)val3).name = "XY Plane (Generated)";
			val3.vertices = Il2CppStructArray<Vector3>.op_Implicit((Vector3[])(object)new Vector3[4]
			{
				new Vector3(0f - num, num, 0f),
				new Vector3(num, num, 0f),
				new Vector3(0f - num, 0f - num, 0f),
				new Vector3(num, 0f - num, 0f)
			});
			val3.uv = Il2CppStructArray<Vector2>.op_Implicit((Vector2[])(object)new Vector2[4]
			{
				new Vector2(0f, 1f),
				new Vector2(1f, 1f),
				new Vector2(0f, 0f),
				new Vector2(1f, 0f)
			});
			val3.triangles = Il2CppStructArray<int>.op_Implicit(new int[12]
			{
				0, 1, 2, 1, 3, 2, 0, 2, 1, 1,
				2, 3
			});
			val3.normals = Il2CppStructArray<Vector3>.op_Implicit((Vector3[])(object)new Vector3[4]
			{
				new Vector3(0f, 0f, -1f),
				new Vector3(0f, 0f, -1f),
				new Vector3(0f, 0f, -1f),
				new Vector3(0f, 0f, -1f)
			});
			Mesh val4 = val3;
			val4.RecalculateTangents();
			return val4;
		}
	}
	public class OverlayGenerator_Load : IOverlayGenerator
	{
		public const string Name = "Load";

		public virtual bool GenerateOverlay(string? thisName, ConversionContext context)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			string[] parameters = FactoryManager.GetParameters(thisName);
			if (parameters.Length == 0)
			{
				context.Log.LogError((object)"OverlayGenerator_Load expected a sight's persistent ID in its parameters, but instead got nothing");
				return false;
			}
			string text = parameters[0];
			bool flag = default(bool);
			if (!uint.TryParse(text, out var result))
			{
				ManualLogSource log = context.Log;
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(57, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("OverlayGenerator_Load failed to parse uint from string \"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
				}
				log.LogError(val);
				return false;
			}
			GearIDRange val2 = new GearIDRange();
			val2.SetCompID((eGearComponent)21, result, false);
			context.Item.GearPartHolder.SpawnGearPartsAsynch(val2, false, (Action)null);
			ManualLogSource log2 = context.Log;
			BepInExDebugLogInterpolatedStringHandler val3 = new BepInExDebugLogInterpolatedStringHandler(67, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("OverlayGenerator_Load successfully triggered async load of sight \"");
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<uint>(result);
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("\"");
			}
			log2.LogDebug(val3);
			return false;
		}
	}
	public class OverlayGenerator_Standard : IOverlayGenerator
	{
		public const string Name = "Standard";

		public virtual bool GenerateOverlay(string? thisName, ConversionContext context)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: 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_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Expected O, but got Unknown
			GameObject val = new GameObject
			{
				name = "Thermal Overlay",
				hideFlags = (HideFlags)52
			};
			bool flag = true;
			string[] parameters = FactoryManager.GetParameters(thisName);
			bool flag2 = default(bool);
			if (parameters.Length != 0)
			{
				string text = parameters[0];
				if (text.Length != 0)
				{
					if (text == "AttachRear")
					{
						flag = true;
					}
					else if (text == "AttachFront")
					{
						flag = false;
					}
					else
					{
						ManualLogSource log = context.Log;
						BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(115, 1, ref flag2);
						if (flag2)
						{
							((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("OverlayGenerator_Standard expected either \"AttachRear\" or \"AttachFront\" for its first parameter, but instead got \"");
							((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(text);
							((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("\"");
						}
						log.LogError(val2);
					}
				}
			}
			if (parameters.Length > 1)
			{
				ManualLogSource log2 = context.Log;
				BepInExWarningLogInterpolatedStringHandler val3 = new BepInExWarningLogInterpolatedStringHandler(53, 1, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("OverlayGenerator_Standard ignoring extra parameters: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(FactoryManager.FormatParams(parameters[1..]));
				}
				log2.LogWarning(val3);
			}
			MeshFilter val4 = val.AddComponent<MeshFilter>();
			val4.mesh = context.Factory.RunMeshGenerator(context.Config?.OverlayConfig.MeshGenerator, context);
			float num = 0f;
			Transform val5;
			if ((Object)(object)context.Item.GearPartHolder.MeleeHeadPart != (Object)null)
			{
				val5 = context.Item.GearPartHolder.MeleeHeadPart.transform;
			}
			else
			{
				val5 = context.Item.SightLookAlign;
				int childCount = val5.GetChildCount();
				for (int i = 0; i < childCount; i++)
				{
					Transform child = val5.GetChild(i);
					num = ((!flag) ? Mathf.Max(num, val5.TransformDirection(child.localPosition).z) : Mathf.Min(num, val5.TransformDirection(child.localPosition).z));
				}
			}
			val.transform.SetParent(val5);
			val.transform.localPosition = (context.Config?.OverlayConfig.MeshOffset ?? Vector3.zero) + num * Vector3.forward;
			ThermalConfig? config = context.Config;
			if (config != null)
			{
				_ = config.OverlayConfig.MeshScale;
				if (true)
				{
					val.transform.localScale = Vector3.Scale(val.transform.localScale, context.Config.OverlayConfig.MeshScale);
				}
			}
			ThermalConfig? config2 = context.Config;
			if (config2 != null)
			{
				_ = config2.OverlayConfig.MeshRotation;
				if (true)
				{
					val.transform.rotation = context.Config.OverlayConfig.MeshRotation * val.transform.rotation;
				}
			}
			context.Renderer = (Renderer?)(object)val.AddComponent<MeshRenderer>();
			context.Material = context.Factory.RunMaterialGenerator(context.Config?.MaterialGenerator, context);
			context.Material.mainTexture = context.Factory.RunTextureGenerator(context.Config?.OverlayConfig.TextureGenerator, context);
			context.Material.SetFloat("_CenterWhenUnscoped", 0f);
			context.Material.SetFloat("_OffAngleFade", 0f);
			context.Renderer.sharedMaterial = context.Material;
			ManualLogSource log3 = context.Log;
			BepInExDebugLogInterpolatedStringHandler val6 = new BepInExDebugLogInterpolatedStringHandler(63, 1, ref flag2);
			if (flag2)
			{
				((BepInExLogInterpolatedStringHandler)val6).AppendLiteral("OverlayGenerator_Standard successfully added overlay to item \"");
				((BepInExLogInterpolatedStringHandler)val6).AppendFormatted<string>(((Object)context.Item).name);
				((BepInExLogInterpolatedStringHandler)val6).AppendLiteral("\"");
			}
			log3.LogDebug(val6);
			return true;
		}
	}
	public class SightConverter_Standard : ISightConverter
	{
		public const string Name = "Standard";

		public static readonly MaterialConfig ThermalDefaults = new MaterialConfig
		{
			MainTex = "red",
			AlphaMult = 1f,
			CenterWhenUnscoped = 1f,
			UncenterWhenScoped = 1f
		};

		public virtual bool ConvertSight(string? thisName, ConversionContext context)
		{
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Expected O, but got Unknown
			Shader thermalOverlayShader = context.Plugin.AssetBundle.ThermalOverlayShader;
			if ((Object)(object)thermalOverlayShader == (Object)null)
			{
				context.Log.LogError((object)"SightConverter_Standard failed; failed to load thermal shader");
				return false;
			}
			if ((Object)(object)context.Renderer == (Object)null)
			{
				context.Log.LogError((object)"SightConverter_Standard failed; context.Renderer was null");
				return false;
			}
			bool flag = ((Object)context.Renderer.sharedMaterial.shader).name.Contains("Thermal", StringComparison.OrdinalIgnoreCase);
			bool flag2 = false;
			string[] parameters = FactoryManager.GetParameters(thisName);
			bool flag3 = default(bool);
			if (parameters.Length != 0)
			{
				string text = parameters[0];
				if (text.Length != 0)
				{
					if (text == "Thermal")
					{
						flag = true;
					}
					else if (text == "NonThermal")
					{
						flag = false;
					}
					else
					{
						ManualLogSource log = context.Log;
						BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(109, 1, ref flag3);
						if (flag3)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("SightConverter_Standard expected either \"Thermal\" or \"NonThermal\" for its first parameter, but instead got \"");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
						}
						log.LogError(val);
					}
				}
			}
			if (parameters.Length > 1)
			{
				ManualLogSource log2 = context.Log;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(51, 1, ref flag3);
				if (flag3)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("SightConverter_Standard ignoring extra parameters: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(FactoryManager.FormatParams(parameters[1..]));
				}
				log2.LogWarning(val2);
			}
			bool flag4 = ((!flag) ? ConvertNonThermalSight(context) : ConvertThermalSight(context));
			if (flag4)
			{
				if ((Object)(object)context.Material == (Object)null)
				{
					throw new NullReferenceException("context.Material should not be null here!");
				}
				context.Material.SetFloat("_CenterWhenUnscoped", 1f);
				if (flag2)
				{
					context.Material.SetFloat("_UncenterWhenScoped", 0f);
					context.Material.mainTexture = context.Factory.RunTextureGenerator("red", context);
				}
				ManualLogSource log3 = context.Log;
				BepInExDebugLogInterpolatedStringHandler val3 = new BepInExDebugLogInterpolatedStringHandler(40, 2, ref flag3);
				if (flag3)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(thisName ?? "SightConverter_Standard");
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" successfully converted sight on item \"");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(((Object)context.Item).name);
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("\"");
				}
				log3.LogDebug(val3);
			}
			return flag4;
		}

		protected virtual bool ConvertThermalSight(ConversionContext context)
		{
			if ((Object)(object)context.Renderer == (Object)null)
			{
				throw new NullReferenceException("context.Renderer should not be null here!");
			}
			context.Material = context.Renderer.material;
			bool flag = context.Material.GetFloat("_BodyOcclusionHeat") == 0f && context.Material.GetFloat("_ShadowEnemyHeat") == 0f && context.Material.GetFloat("_ShadowEnemyFresnel") == 0f;
			MaterialConfig materialConfig = MaterialConfig.FromMaterial(context.Material, removeDefault: false);
			context.Material.shader = context.Plugin.AssetBundle.ThermalOverlayShader;
			materialConfig.Zoom = Mathf.Clamp(materialConfig.Zoom.Value - 0.5f, 0f, 1f);
			materialConfig.ApplyAllWithDefaults(context.Material, context, skipTextures: true);
			ThermalDefaults.ApplyAll(context.Material, context);
			if (flag)
			{
				context.Material.SetFloat("_ShadowEnemyFresnel", 50f);
				context.Material.SetFloat("_ShadowEnemyHeat", 0.6f);
				context.Material.SetFloat("_BodyOcclusionHeat", 1f);
			}
			return true;
		}

		protected virtual bool ConvertNonThermalSight(ConversionContext context)
		{
			if ((Object)(object)context.Renderer == (Object)null)
			{
				throw new NullReferenceException("context.Renderer should not be null here!");
			}
			context.Material = context.Plugin.FactoryManager.RunMaterialGenerator(context.Config?.MaterialGenerator, context);
			context.Material.mainTexture = context.Renderer.sharedMaterial.mainTexture;
			foreach (string item in (Il2CppArrayBase<string>)(object)context.Renderer.sharedMaterial.GetShaderKeywords())
			{
				MaterialExtensions.SetKeywordEnabled(context.Material, item, true);
			}
			context.Renderer.sharedMaterials = Il2CppReferenceArray<Material>.op_Implicit(((IEnumerable<Material>)context.Renderer.sharedMaterials).Append(context.Material).ToArray());
			return true;
		}
	}
	public class TextureGenerator_Bloom : ITextureGenerator
	{
		public const string Name = "Bloom";

		public virtual Texture GenerateTexture(string? thisName, ConversionContext context)
		{
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Expected O, but got Unknown
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Expected O, but got Unknown
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Expected O, but got Unknown
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Expected O, but got Unknown
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			bool flag = true;
			float num = 0f;
			float num2 = 1f;
			int num3 = 256;
			string[] parameters = FactoryManager.GetParameters(thisName);
			bool flag2 = default(bool);
			if (parameters.Length != 0)
			{
				string text = parameters[0];
				if (text.Length != 0)
				{
					if (text == "Circle")
					{
						flag = true;
					}
					else if (text == "Square")
					{
						flag = false;
					}
					else
					{
						ManualLogSource log = context.Log;
						BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(103, 1, ref flag2);
						if (flag2)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("TextureGenerator_Bloom expected either \"Circle\" or \"Square\" for its first parameter, but instead got \"");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
						}
						log.LogError(val);
					}
				}
			}
			if (parameters.Length > 1)
			{
				string text2 = parameters[1];
				if (text2.Length != 0)
				{
					if (float.TryParse(text2, out var result))
					{
						num = result;
					}
					else
					{
						ManualLogSource log2 = context.Log;
						BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(84, 1, ref flag2);
						if (flag2)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("TextureGenerator_Bloom expected a float for its second parameter, but instead got \"");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text2);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
						}
						log2.LogError(val);
					}
				}
			}
			if (parameters.Length > 2)
			{
				string text3 = parameters[2];
				if (text3.Length != 0)
				{
					if (float.TryParse(text3, out var result2))
					{
						num2 = result2;
					}
					else
					{
						ManualLogSource log3 = context.Log;
						BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(83, 1, ref flag2);
						if (flag2)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("TextureGenerator_Bloom expected a float for its third parameter, but instead got \"");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text3);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
						}
						log3.LogError(val);
					}
				}
			}
			if (parameters.Length > 3)
			{
				string text4 = parameters[3];
				if (text4.Length != 0)
				{
					if (uint.TryParse(text4, out var result3))
					{
						num3 = (int)result3;
					}
					else
					{
						ManualLogSource log4 = context.Log;
						BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(83, 1, ref flag2);
						if (flag2)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("TextureGenerator_Bloom expected a uint for its fourth parameter, but instead got \"");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text4);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
						}
						log4.LogError(val);
					}
				}
			}
			if (parameters.Length > 4)
			{
				ManualLogSource log5 = context.Log;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(50, 1, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("TextureGenerator_Bloom ignoring extra parameters: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(FactoryManager.FormatParams(parameters[4..]));
				}
				log5.LogWarning(val2);
			}
			float num4 = 0.5f * ((float)num3 - 1f);
			float num5 = 1f / num4;
			Texture2D val3 = new Texture2D(num3, num3, (TextureFormat)15, false);
			if (flag)
			{
				((Object)val3).name = "Bloom - Circle";
			}
			else
			{
				((Object)val3).name = "Bloom - Square";
			}
			for (int i = 0; i < num3; i++)
			{
				float num6 = (float)i - num4;
				for (int j = 0; j < num3; j++)
				{
					float num7 = (float)j - num4;
					float num8 = ((!flag) ? (Mathf.Max(Mathf.Abs(num6), Mathf.Abs(num7)) * num5) : (Mathf.Sqrt(num6 * num6 + num7 * num7) * num5));
					num8 = Mathf.Lerp(num, num2, Mathf.Clamp(1f - num8, 0f, 1f));
					val3.SetPixel(i, j, new Color(num8, 0f, 0f));
				}
			}
			val3.Apply();
			return (Texture)(object)val3;
		}
	}
	public class TextureGenerator_Load : ITextureGenerator
	{
		public const string Name = "Load";

		public static string TexturesPath => AssetBundle.AssetDirectory;

		public virtual Texture GenerateTexture(string? thisName, ConversionContext context)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			string[] parameters = FactoryManager.GetParameters(thisName);
			bool flag = default(bool);
			if (parameters.Length == 0)
			{
				ManualLogSource log = context.Log;
				BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(85, 0, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("TextureGenerator_File expected a file path in its parameters, but instead got nothing");
				}
				log.LogDebug(val);
				return context.Factory.RunTextureGenerator(null, context);
			}
			string text = Path.Combine(parameters);
			string text2 = Path.Combine(TexturesPath, text);
			if (File.Exists(text2))
			{
				Texture2D val2 = new Texture2D(2, 2);
				((Object)val2).name = text;
				ImageConversion.LoadImage(val2, Il2CppStructArray<byte>.op_Implicit(File.ReadAllBytes(text2)));
				val2.Apply();
				return (Texture)(object)val2;
			}
			ManualLogSource log2 = context.Log;
			BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(87, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("TextureGenerator_File failed to load file; file not found\n - File name: ");
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(text);
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("\n - Full path: ");
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(text2);
			}
			log2.LogError(val3);
			return context.Factory.RunTextureGenerator(null, context);
		}
	}
	public class TextureGenerator_Simple : ITextureGenerator
	{
		private Func<Texture> Func;

		public TextureGenerator_Simple(Func<Texture> func)
		{
			Func = func;
		}

		public virtual Texture GenerateTexture(string? t