using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using OpenShot;
using OpenShot.Events;
using OpenShot.UI;
using Shooterlatro.Core;
using Shooterlatro.Game;
using Shooterlatro.Input;
using Shooterlatro.Weapons;
using UnityEngine;
using UnityEngine.InputSystem;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("Menugun")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Dedicated menu pistol for Lucky Shot: high fire rate, outline look, one shot per click. Configure via OpenShot MODS hub.")]
[assembly: AssemblyFileVersion("1.2.0.0")]
[assembly: AssemblyInformationalVersion("1.2.0+4135dd1490a61fe647f2a0e54287f36471f5cf7f")]
[assembly: AssemblyProduct("Menugun")]
[assembly: AssemblyTitle("Menugun")]
[assembly: AssemblyVersion("1.2.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Menugun
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.liamgaming.menugun", "Menugun", "1.2.0")]
	public class MenugunPlugin : BaseUnityPlugin
	{
		private struct RendererMaterialBackup
		{
			public Renderer Renderer;

			public Material[] Materials;
		}

		[HarmonyPatch(typeof(WeaponManager), "EquipWeapon")]
		private static class WeaponManager_EquipWeapon_Patch
		{
			private static void Postfix()
			{
				MenugunPlugin instance = Instance;
				if (!((Object)(object)instance == (Object)null) && IsMenuGunActive())
				{
					instance.ReapplyMenuGunState(forceOutline: true);
				}
			}
		}

		[HarmonyPatch(typeof(Weapon), "IsFiringInputHeld")]
		private static class Weapon_IsFiringInputHeld_Patch
		{
			private static void Postfix(ref bool __result)
			{
				if (IsMenuGunActive() && ForceSemiAuto.Value)
				{
					bool flag = Mouse.current != null && Mouse.current.leftButton.wasPressedThisFrame;
					ControllerInputService instance = ControllerInputService.Instance;
					bool flag2 = (Object)(object)instance != (Object)null && instance.WasFirePressedThisFrame();
					__result = flag || flag2;
				}
			}
		}

		[HarmonyPatch(typeof(Weapon), "PlayRecoil")]
		private static class Weapon_PlayRecoil_Patch
		{
			private static bool Prefix()
			{
				if (IsMenuGunActive())
				{
					return !DisableRecoil.Value;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(RecoilController), "ResolveBallistics")]
		private static class RecoilController_ResolveBallistics_Patch
		{
			private static bool Prefix(Vector3 baseDirection, ref RecoilBallisticsResult __result)
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				if (!IsMenuGunActive() || !DisableRecoil.Value)
				{
					return true;
				}
				Vector3 finalDirection = ((((Vector3)(ref baseDirection)).sqrMagnitude > 1E-06f) ? ((Vector3)(ref baseDirection)).normalized : Vector3.forward);
				__result = new RecoilBallisticsResult
				{
					FinalDirection = finalDirection,
					ChainIndex = 0,
					DidReset = false,
					RecoilHorizontalDeg = 0f,
					RecoilVerticalDeg = 0f,
					RecoilDeltaHorizontalDeg = 0f,
					RecoilDeltaVerticalDeg = 0f,
					ChainResetMs = 0f,
					SpreadDeg = 0f
				};
				return false;
			}
		}

		[HarmonyPatch(typeof(RecoilController), "OnShotFired")]
		private static class RecoilController_OnShotFired_Patch
		{
			private static bool Prefix()
			{
				if (IsMenuGunActive())
				{
					return !DisableRecoil.Value;
				}
				return true;
			}
		}

		public const string PluginGuid = "com.liamgaming.menugun";

		public const string PluginName = "Menugun";

		public const string PluginVersion = "1.2.0";

		private const string HologramShaderName = "Shooterlatro/HologramURP";

		private Harmony _harmony;

		private bool _menuModeActive;

		private bool _hadInfiniteAmmo;

		private bool _savedUseAutomaticFire;

		private WeaponData _savedAutomaticWeaponData;

		private readonly List<RendererMaterialBackup> _rendererBackups = new List<RendererMaterialBackup>();

		private readonly List<Material> _outlineMaterials = new List<Material>();

		private GameObject _lastOutlinedModel;

		private Shader _hologramShader;

		private static readonly string[] OutlinePresets = new string[7] { "Ice", "Cyan", "Magenta", "Gold", "Red", "White", "Lime" };

		public static MenugunPlugin Instance { get; private set; }

		public static ManualLogSource Log { get; private set; }

		public static ConfigEntry<bool> Enabled { get; private set; }

		public static ConfigEntry<float> MenuFireRate { get; private set; }

		public static ConfigEntry<bool> EnableOutline { get; private set; }

		public static ConfigEntry<bool> HideKeychain { get; private set; }

		public static ConfigEntry<bool> DisableRecoil { get; private set; }

		public static ConfigEntry<bool> ForceSemiAuto { get; private set; }

		public static ConfigEntry<bool> BasePistolOnly { get; private set; }

		public static ConfigEntry<float> RimIntensity { get; private set; }

		public static ConfigEntry<float> RimPower { get; private set; }

		public static ConfigEntry<float> BaseFill { get; private set; }

		public static ConfigEntry<float> OutlineBrightness { get; private set; }

		public static ConfigEntry<Color> OutlineColor { get; private set; }

		public static ConfigEntry<string> OutlinePreset { get; private set; }

		private void Awake()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Expected O, but got Unknown
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Expected O, but got Unknown
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Expected O, but got Unknown
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Expected O, but got Unknown
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0443: Unknown result type (might be due to invalid IL or missing references)
			//IL_044d: Expected O, but got Unknown
			//IL_048a: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			Enabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "Use the first pistol as a dedicated menu gun in menus.");
			MenuFireRate = ((BaseUnityPlugin)this).Config.Bind<float>("MenuGun", "FireRate", 30f, new ConfigDescription("Shots per second while the menu gun is active (still max 1 shot per click).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 60f), Array.Empty<object>()));
			EnableOutline = ((BaseUnityPlugin)this).Config.Bind<bool>("MenuGun", "EnableOutline", true, "Apply hologram outline look on the menu pistol.");
			HideKeychain = ((BaseUnityPlugin)this).Config.Bind<bool>("MenuGun", "HideKeychain", true, "Hide keychain/charm visuals while menu gun is active.");
			DisableRecoil = ((BaseUnityPlugin)this).Config.Bind<bool>("MenuGun", "DisableRecoil", true, "Suppress recoil / ballistics kick in menus.");
			ForceSemiAuto = ((BaseUnityPlugin)this).Config.Bind<bool>("MenuGun", "ForceSemiAuto", true, "Force one shot per click (disable automatic fire).");
			BasePistolOnly = ((BaseUnityPlugin)this).Config.Bind<bool>("MenuGun", "BasePistolOnly", true, "Prefer the base pistol (no skin variations) as menu gun.");
			RimIntensity = ((BaseUnityPlugin)this).Config.Bind<float>("MenuGun", "RimIntensity", 3f, new ConfigDescription("Outline edge strength (higher = stronger rim).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 5f), Array.Empty<object>()));
			RimPower = ((BaseUnityPlugin)this).Config.Bind<float>("MenuGun", "RimPower", 5.5f, new ConfigDescription("Outline thinness (higher = tighter edge, less fill).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 8f), Array.Empty<object>()));
			BaseFill = ((BaseUnityPlugin)this).Config.Bind<float>("MenuGun", "BaseFill", 0.03f, new ConfigDescription("Interior fill brightness. Keep near 0 for outline-only.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 0.35f), Array.Empty<object>()));
			OutlineBrightness = ((BaseUnityPlugin)this).Config.Bind<float>("MenuGun", "OutlineBrightness", 3.2f, new ConfigDescription("Hologram brightness multiplier for the outline material.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 8f), Array.Empty<object>()));
			OutlineColor = ((BaseUnityPlugin)this).Config.Bind<Color>("MenuGun", "OutlineColor", new Color(0.85f, 0.9f, 1f, 1f), "Rim / outline tint color.");
			OutlinePreset = ((BaseUnityPlugin)this).Config.Bind<string>("MenuGun", "OutlinePreset", "Ice", "Named outline color preset (Ice, Cyan, Magenta, Gold, Red, White, Lime).");
			ModMenu.Tab("Menugun").Toggle(Enabled).Info("— Behaviour —")
				.Float("Fire Rate", MenuFireRate, 1f, "F0")
				.Bool("Force Semi-Auto", ForceSemiAuto)
				.Bool("Disable Recoil", DisableRecoil)
				.Bool("Hide Keychain", HideKeychain)
				.Bool("Base Pistol Only", BasePistolOnly)
				.Info("— Outline —")
				.Bool("Enable Outline", EnableOutline)
				.Cycle("Color Preset", (Func<string>)(() => OutlinePreset.Value), (Action)CycleOutlinePreset)
				.Float("Rim Intensity", RimIntensity, 0.1f, "F1")
				.Float("Rim Power", RimPower, 0.1f, "F1")
				.Float("Base Fill", BaseFill, 0.01f, "F2")
				.Float("Brightness", OutlineBrightness, 0.1f, "F1")
				.Button("Reapply Look", (Action)delegate
				{
					if (IsMenuGunActive())
					{
						Instance?.ApplyOutlineIfNeeded(force: true);
					}
				});
			OutlinePreset.SettingChanged += delegate
			{
				ApplyOutlinePreset(OutlinePreset.Value);
			};
			ApplyOutlinePreset(OutlinePreset.Value);
			EnableOutline.SettingChanged += delegate
			{
				if (IsMenuGunActive())
				{
					if (EnableOutline.Value)
					{
						Instance?.ApplyOutlineIfNeeded(force: true);
					}
					else
					{
						Instance?.RestoreOriginalMaterials();
					}
				}
			};
			OpenShotApi.OnSettingsChanged += HandleSettingsChanged;
			_harmony = new Harmony("com.liamgaming.menugun");
			_harmony.PatchAll(typeof(MenugunPlugin).Assembly);
			GameEvents.OnGamePhaseChanged += HandleGamePhaseChanged;
			if ((Object)(object)GameManager.Instance != (Object)null && IsMenuPhase(GameManager.Instance.Phase))
			{
				EnterMenuGunMode();
			}
			Log.LogInfo((object)"Menugun v1.2.0 loaded (OpenShot 2.0.0).");
		}

		private static void CycleOutlinePreset()
		{
			int num = Array.IndexOf(OutlinePresets, OutlinePreset.Value);
			if (num < 0)
			{
				num = 0;
			}
			OutlinePreset.Value = OutlinePresets[(num + 1) % OutlinePresets.Length];
		}

		private static void ApplyOutlinePreset(string name)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			ConfigEntry<Color> outlineColor = OutlineColor;
			outlineColor.Value = (Color)(name switch
			{
				"Cyan" => new Color(0.2f, 0.95f, 1f, 1f), 
				"Magenta" => new Color(1f, 0.25f, 0.9f, 1f), 
				"Gold" => new Color(1f, 0.82f, 0.25f, 1f), 
				"Red" => new Color(1f, 0.28f, 0.28f, 1f), 
				"White" => new Color(1f, 1f, 1f, 1f), 
				"Lime" => new Color(0.45f, 1f, 0.35f, 1f), 
				_ => new Color(0.85f, 0.9f, 1f, 1f), 
			});
			if (IsMenuGunActive() && EnableOutline.Value)
			{
				Instance?.ApplyOutlineIfNeeded(force: true);
			}
		}

		private void OnDestroy()
		{
			OpenShotApi.OnSettingsChanged -= HandleSettingsChanged;
			GameEvents.OnGamePhaseChanged -= HandleGamePhaseChanged;
			ExitMenuGunMode();
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		private void Update()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (!Enabled.Value)
			{
				if (_menuModeActive)
				{
					ExitMenuGunMode();
				}
				return;
			}
			GameManager instance = GameManager.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				bool flag = IsMenuPhase(instance.Phase);
				if (flag && !_menuModeActive)
				{
					EnterMenuGunMode();
				}
				else if (!flag && _menuModeActive)
				{
					ExitMenuGunMode();
				}
			}
		}

		private static void HandleSettingsChanged(SettingsChangedContext ctx)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (string.Equals(ctx.ModTab, "Menugun", StringComparison.OrdinalIgnoreCase) && IsMenuGunActive())
			{
				Instance?.ReapplyMenuGunState();
			}
		}

		private void ReapplyMenuGunState(bool forceOutline = false)
		{
			EnsureMenuPistolEquipped();
			ApplyMenuStats();
			if (EnableOutline.Value)
			{
				ApplyOutlineIfNeeded(forceOutline);
			}
			else
			{
				RestoreOriginalMaterials();
			}
			SetKeychainHidden(HideKeychain.Value);
		}

		private void HandleGamePhaseChanged(GamePhaseChangedContext ctx)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (Enabled.Value && ctx != null)
			{
				if (IsMenuPhase(ctx.Current))
				{
					EnterMenuGunMode();
				}
				else if (_menuModeActive)
				{
					ExitMenuGunMode();
				}
			}
		}

		internal static bool IsMenuPhase(GamePhase phase)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)phase != 7)
			{
				return (int)phase == 9;
			}
			return true;
		}

		internal static bool IsMenuGunActive()
		{
			if ((Object)(object)Instance != (Object)null && Instance._menuModeActive)
			{
				return Enabled.Value;
			}
			return false;
		}

		private void EnterMenuGunMode()
		{
			if (_menuModeActive)
			{
				EnsureMenuPistolEquipped();
				ApplyMenuStats();
				if (EnableOutline.Value)
				{
					ApplyOutlineIfNeeded(force: true);
				}
				else
				{
					RestoreOriginalMaterials();
				}
				SetKeychainHidden(HideKeychain.Value);
				return;
			}
			Weapon instance = Weapon.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				_hadInfiniteAmmo = instance.HasInfiniteAmmo;
			}
			_menuModeActive = true;
			EnsureMenuPistolEquipped();
			ApplyMenuStats();
			if (EnableOutline.Value)
			{
				ApplyOutlineIfNeeded(force: true);
			}
			SetKeychainHidden(HideKeychain.Value);
			Log.LogInfo((object)"Menu gun active.");
		}

		private void ExitMenuGunMode()
		{
			if (_menuModeActive)
			{
				RestoreOriginalMaterials();
				RestoreMenuStats();
				SetKeychainHidden(hidden: false);
				_menuModeActive = false;
				Log.LogInfo((object)"Menu gun deactivated.");
			}
		}

		private static void SetKeychainHidden(bool hidden)
		{
			WeaponManager instance = WeaponManager.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.SetKeychainCharmVisualsHidden(hidden);
			}
		}

		private void EnsureMenuPistolEquipped()
		{
			WeaponManager instance = WeaponManager.Instance;
			if (!((Object)(object)instance == (Object)null) && instance.AvailableWeapons != null && instance.AvailableWeapons.Count != 0)
			{
				WeaponData val = ResolveMenuPistol(instance);
				if (!((Object)(object)val == (Object)null) && (Object)(object)instance.CurrentWeaponData != (Object)(object)val)
				{
					instance.SwitchToWeapon(val);
				}
			}
		}

		private static WeaponData ResolveMenuPistol(WeaponManager manager)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			IReadOnlyList<WeaponData> availableWeapons = manager.AvailableWeapons;
			if (BasePistolOnly.Value)
			{
				for (int i = 0; i < availableWeapons.Count; i++)
				{
					WeaponData val = availableWeapons[i];
					if ((Object)(object)val != (Object)null && (int)val.weaponName == 0 && (Object)(object)val.variationOf == (Object)null)
					{
						return val;
					}
				}
			}
			for (int j = 0; j < availableWeapons.Count; j++)
			{
				WeaponData val2 = availableWeapons[j];
				if ((Object)(object)val2 != (Object)null && (int)val2.weaponName == 0)
				{
					return val2;
				}
			}
			return availableWeapons[0];
		}

		private void ApplyMenuStats()
		{
			Weapon instance = Weapon.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			float num = Mathf.Clamp(MenuFireRate.Value, 0.1f, 60f);
			Traverse.Create((object)instance).Field("_fireRate").SetValue((object)num);
			Traverse.Create((object)instance).Field("_cooldownSeconds").SetValue((object)0f);
			instance.SetInfiniteAmmo(true);
			WeaponData weaponData = instance.WeaponData;
			if ((Object)(object)weaponData != (Object)null && ForceSemiAuto.Value)
			{
				if ((Object)(object)_savedAutomaticWeaponData != (Object)(object)weaponData)
				{
					_savedUseAutomaticFire = weaponData.useAutomaticFire;
					_savedAutomaticWeaponData = weaponData;
				}
				weaponData.useAutomaticFire = false;
			}
		}

		private void RestoreMenuStats()
		{
			Weapon instance = Weapon.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				if ((Object)(object)instance.WeaponData != (Object)null)
				{
					Traverse.Create((object)instance).Field("_fireRate").SetValue((object)Mathf.Clamp(instance.WeaponData.fireRate, 0.1f, 60f));
				}
				instance.SetInfiniteAmmo(_hadInfiniteAmmo);
			}
			if ((Object)(object)_savedAutomaticWeaponData != (Object)null)
			{
				_savedAutomaticWeaponData.useAutomaticFire = _savedUseAutomaticFire;
				_savedAutomaticWeaponData = null;
			}
		}

		private void ApplyOutlineIfNeeded(bool force)
		{
			WeaponManager instance = WeaponManager.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				GameObject value = Traverse.Create((object)instance).Field("_currentWeaponModel").GetValue<GameObject>();
				if (!((Object)(object)value == (Object)null) && (force || !((Object)(object)value == (Object)(object)_lastOutlinedModel) || _rendererBackups.Count <= 0))
				{
					RestoreOriginalMaterials();
					ApplyOutlineLook(value);
					_lastOutlinedModel = value;
				}
			}
		}

		private Shader ResolveHologramShader()
		{
			if ((Object)(object)_hologramShader != (Object)null)
			{
				return _hologramShader;
			}
			_hologramShader = Shader.Find("Shooterlatro/HologramURP");
			if ((Object)(object)_hologramShader == (Object)null)
			{
				Log.LogWarning((object)"Could not find shader 'Shooterlatro/HologramURP'. Outline look unavailable.");
			}
			return _hologramShader;
		}

		private void ApplyOutlineLook(GameObject model)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Expected O, but got Unknown
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			Shader val = ResolveHologramShader();
			if ((Object)(object)val == (Object)null || !EnableOutline.Value)
			{
				return;
			}
			Color value = OutlineColor.Value;
			float value2 = RimIntensity.Value;
			float value3 = RimPower.Value;
			float value4 = BaseFill.Value;
			float value5 = OutlineBrightness.Value;
			Renderer[] componentsInChildren = model.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val2 in componentsInChildren)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				Material[] materials = val2.materials;
				if (materials != null && materials.Length != 0)
				{
					_rendererBackups.Add(new RendererMaterialBackup
					{
						Renderer = val2,
						Materials = materials
					});
					Material[] array = (Material[])(object)new Material[materials.Length];
					for (int j = 0; j < materials.Length; j++)
					{
						Material val3 = new Material(val)
						{
							name = (((Object)(object)materials[j] != (Object)null) ? ((Object)materials[j]).name : "Weapon") + " (Menugun Outline)"
						};
						ConfigureOutlineMaterial(val3, value, value2, value3, value4, value5);
						array[j] = val3;
						_outlineMaterials.Add(val3);
					}
					val2.materials = array;
				}
			}
		}

		private static void ConfigureOutlineMaterial(Material mat, Color tint, float rim, float power, float fill, float brightness)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (mat.HasProperty("_Tint"))
			{
				mat.SetColor("_Tint", tint);
			}
			if (mat.HasProperty("_Color"))
			{
				mat.SetColor("_Color", tint);
			}
			if (mat.HasProperty("_BaseColor"))
			{
				mat.SetColor("_BaseColor", tint);
			}
			if (mat.HasProperty("_Brightness"))
			{
				mat.SetFloat("_Brightness", brightness);
			}
			if (mat.HasProperty("_BaseIntensity"))
			{
				mat.SetFloat("_BaseIntensity", fill);
			}
			if (mat.HasProperty("_RimPower"))
			{
				mat.SetFloat("_RimPower", power);
			}
			if (mat.HasProperty("_RimIntensity"))
			{
				mat.SetFloat("_RimIntensity", rim);
			}
			if (mat.HasProperty("_GridIntensity"))
			{
				mat.SetFloat("_GridIntensity", 0f);
			}
			if (mat.HasProperty("_ScanIntensity"))
			{
				mat.SetFloat("_ScanIntensity", 0f);
			}
			if (mat.HasProperty("_NoiseIntensity"))
			{
				mat.SetFloat("_NoiseIntensity", 0f);
			}
			if (mat.HasProperty("_SoftFade"))
			{
				mat.SetFloat("_SoftFade", 0f);
			}
			if (mat.HasProperty("_UseMainTex"))
			{
				mat.SetFloat("_UseMainTex", 0f);
			}
			if (mat.HasProperty("_HueOnly"))
			{
				mat.SetFloat("_HueOnly", 1f);
			}
			if (mat.HasProperty("_Render_Over_Everything"))
			{
				mat.SetFloat("_Render_Over_Everything", 1f);
			}
			if (mat.HasProperty("_ZTest"))
			{
				mat.SetFloat("_ZTest", 4f);
			}
			if (mat.HasProperty("_ZWrite"))
			{
				mat.SetFloat("_ZWrite", 0f);
			}
			mat.EnableKeyword("_HUE_ONLY");
			mat.DisableKeyword("_USE_MAINTEX");
			mat.renderQueue = 4000;
		}

		private void RestoreOriginalMaterials()
		{
			for (int i = 0; i < _rendererBackups.Count; i++)
			{
				RendererMaterialBackup rendererMaterialBackup = _rendererBackups[i];
				if ((Object)(object)rendererMaterialBackup.Renderer != (Object)null && rendererMaterialBackup.Materials != null)
				{
					rendererMaterialBackup.Renderer.materials = rendererMaterialBackup.Materials;
				}
			}
			_rendererBackups.Clear();
			for (int j = 0; j < _outlineMaterials.Count; j++)
			{
				if ((Object)(object)_outlineMaterials[j] != (Object)null)
				{
					Object.Destroy((Object)(object)_outlineMaterials[j]);
				}
			}
			_outlineMaterials.Clear();
			_lastOutlinedModel = null;
		}
	}
}