using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ScanRecolor")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("A scan recoloring mod for Lethal Company")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+299b7aa673cb87e11068e44dd04c7c40c9566e19")]
[assembly: AssemblyProduct("ScanRecolor")]
[assembly: AssemblyTitle("ScanRecolor")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace ScanRecolor
{
public sealed class Config
{
private static Config instance;
public ConfigEntry<bool> FadeOut { get; set; }
public ConfigEntry<bool> RecolorScanLines { get; set; }
public ConfigEntry<int> Red { get; set; }
public ConfigEntry<int> Green { get; set; }
public ConfigEntry<int> Blue { get; set; }
public ConfigEntry<float> Alpha { get; set; }
public ConfigEntry<float> VignetteIntensity { get; set; }
public ConfigEntry<bool> RandomColor { get; set; }
public static Config Instance
{
get
{
if (instance == null)
{
instance = new Config();
}
return instance;
}
}
public void Setup()
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Expected O, but got Unknown
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Expected O, but got Unknown
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Expected O, but got Unknown
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Expected O, but got Unknown
//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
//IL_00f5: Expected O, but got Unknown
//IL_0128: Unknown result type (might be due to invalid IL or missing references)
//IL_0132: Expected O, but got Unknown
//IL_0165: Unknown result type (might be due to invalid IL or missing references)
//IL_016f: Expected O, but got Unknown
FadeOut = Plugin.BepInExConfig().Bind<bool>("General", "FadeOut", false, new ConfigDescription("Fade out effect for scan color.", (AcceptableValueBase)null, Array.Empty<object>()));
RecolorScanLines = Plugin.BepInExConfig().Bind<bool>("General", "RecolorScanLines", true, new ConfigDescription("Recolor the blue horizontal scan lines texture aswell.", (AcceptableValueBase)null, Array.Empty<object>()));
Red = Plugin.BepInExConfig().Bind<int>("Color", "Red", 0, new ConfigDescription("Red scan color.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 255), Array.Empty<object>()));
Green = Plugin.BepInExConfig().Bind<int>("Color", "Green", 12, new ConfigDescription("Green scan color.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 255), Array.Empty<object>()));
Blue = Plugin.BepInExConfig().Bind<int>("Color", "Blue", 255, new ConfigDescription("Blue scan color.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 255), Array.Empty<object>()));
Alpha = Plugin.BepInExConfig().Bind<float>("Color", "Alpha", 0.26f, new ConfigDescription("Alpha / opacity.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
VignetteIntensity = Plugin.BepInExConfig().Bind<float>("Color", "VignetteIntensity", 0.46f, new ConfigDescription("Intensity of the vignette / borders effect during scan.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
RandomColor = Plugin.BepInExConfig().Bind<bool>("Color", "RandomColor", false, "Random color on each scan (ignores other Color settings)");
Red.SettingChanged += delegate
{
HUDManagerPatch.SetScanColor();
};
Green.SettingChanged += delegate
{
HUDManagerPatch.SetScanColor();
};
Blue.SettingChanged += delegate
{
HUDManagerPatch.SetScanColor();
};
Alpha.SettingChanged += delegate
{
HUDManagerPatch.SetScanColor();
};
FadeOut.SettingChanged += delegate
{
HUDManagerPatch.SetScanColor();
};
RandomColor.SettingChanged += delegate
{
if (!RandomColor.Value)
{
HUDManagerPatch.SetScanColor();
}
};
VignetteIntensity.SettingChanged += delegate
{
HUDManagerPatch.UpdateVignetteIntensity();
};
RecolorScanLines.SettingChanged += delegate
{
HUDManagerPatch.UpdateScanTexture();
};
}
}
[HarmonyPatch]
internal static class HUDManagerPatch
{
private static readonly float ScanDuration = 1.3f;
private static Texture2D _baseTexture = null;
private static MeshRenderer _scanRenderer;
private static Volume _scanVolume;
private static Vignette _scanVignette;
private static Bloom _scanBloom;
private static bool HasScanMaterial
{
get
{
if (ScanRenderer != null)
{
return ((Renderer)ScanRenderer).material != null;
}
return false;
}
}
public static MeshRenderer ScanRenderer
{
get
{
if (_scanRenderer == null || ((Renderer)_scanRenderer).material == null)
{
if (HUDManager.Instance == null || HUDManager.Instance.scanEffectAnimator == null)
{
return null;
}
if (!((Component)HUDManager.Instance.scanEffectAnimator).TryGetComponent<MeshRenderer>(ref _scanRenderer))
{
return null;
}
}
return _scanRenderer;
}
}
public static Volume ScanVolume => _scanVolume ?? (_scanVolume = Object.FindObjectsByType<Volume>((FindObjectsSortMode)0)?.Where(delegate(Volume v)
{
bool? obj;
if (v == null)
{
obj = null;
}
else
{
VolumeProfile profile = v.profile;
obj = ((profile == null) ? null : ((Object)profile).name?.StartsWith("ScanVolume"));
}
bool? flag = obj;
return flag.GetValueOrDefault();
})?.FirstOrDefault());
public static Vignette ScanVignette
{
get
{
Vignette obj = _scanVignette;
if (obj == null)
{
Volume scanVolume = ScanVolume;
VolumeComponent? obj2 = ((scanVolume == null) ? null : scanVolume.profile?.components?.Where((VolumeComponent c) => ((c == null) ? null : ((Object)c).name?.StartsWith("Vignette")).GetValueOrDefault())?.FirstOrDefault());
obj = (_scanVignette = (Vignette)(object)((obj2 is Vignette) ? obj2 : null));
}
return obj;
}
}
public static Bloom ScanBloom
{
get
{
Bloom obj = _scanBloom;
if (obj == null)
{
Volume scanVolume = ScanVolume;
VolumeComponent? obj2 = ((scanVolume == null) ? null : scanVolume.profile?.components?.Where((VolumeComponent c) => ((c == null) ? null : ((Object)c).name?.StartsWith("Bloom")).GetValueOrDefault())?.FirstOrDefault());
obj = (_scanBloom = (Bloom)(object)((obj2 is Bloom) ? obj2 : null));
}
return obj;
}
}
private static Color RandomColor => new Color(Random.Range(0f, 1f), Random.Range(0f, 1f), Random.Range(0f, 1f), Random.Range(0.26f, 1f));
private static float ScanProgress => 1f / ScanDuration * (HUDManager.Instance.playerPingingScan + 1f);
private static float ColorToFloat(int color)
{
return 0.003921569f * (float)color;
}
private static Color ScanColor(float? overrideAlpha = null)
{
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
return new Color(ColorToFloat(Config.Instance.Red.Value), ColorToFloat(Config.Instance.Green.Value), ColorToFloat(Config.Instance.Blue.Value), overrideAlpha.GetValueOrDefault(Config.Instance.Alpha.Value));
}
public static void SetScanColorAlpha(float alpha)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
if (HasScanMaterial)
{
Color color = ((Renderer)ScanRenderer).material.color;
color.a = alpha;
((Renderer)ScanRenderer).material.color = color;
}
}
public static void SetScanColor(Color? scanColor = null)
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: 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)
if (HasScanMaterial)
{
((Renderer)ScanRenderer).material.color = (Color)(((??)scanColor) ?? ScanColor());
}
if (ScanVignette != null)
{
((VolumeParameter<Color>)(object)ScanVignette.color).value = (Color)(((??)scanColor) ?? ScanColor(1f));
UpdateVignetteIntensity();
}
if (ScanBloom != null)
{
((VolumeParameter<Color>)(object)ScanBloom.tint).Override((Color)(((??)scanColor) ?? ScanColor()));
UpdateScanTexture();
}
}
public static void UpdateVignetteIntensity()
{
if (ScanVignette != null)
{
((VolumeParameter<float>)(object)ScanVignette.intensity).value = Config.Instance.VignetteIntensity.Value;
}
}
public static void UpdateScanTexture()
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
if (Config.Instance.RecolorScanLines.Value)
{
RecolorScanTexture(ScanColor());
}
else
{
RevertScanTexture();
}
}
public static void RecolorScanTexture(Color color)
{
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Expected O, but got Unknown
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
if (ScanBloom == null || ScanBloom.dirtTexture == null)
{
return;
}
if (_baseTexture == null)
{
Texture obj = Utils.MakeTextureReadable(((VolumeParameter<Texture>)(object)ScanBloom.dirtTexture).value);
_baseTexture = (Texture2D)(object)((obj is Texture2D) ? obj : null);
if (!((Texture)_baseTexture).isReadable)
{
Plugin.mls.LogWarning((object)"Unable to read ScanTexture.");
return;
}
}
Texture2D texture = new Texture2D(((Texture)_baseTexture).width, ((Texture)_baseTexture).height);
texture.SetPixels(_baseTexture.GetPixels());
texture.Apply();
Utils.RecolorTexture(ref texture, color);
((VolumeParameter<Texture>)(object)ScanBloom.dirtTexture).Override((Texture)(object)Object.Instantiate<Texture2D>(texture));
}
public static void RevertScanTexture()
{
if (_baseTexture != null && ScanBloom != null && ScanBloom.dirtTexture != null)
{
((VolumeParameter<Texture>)(object)ScanBloom.dirtTexture).Override((Texture)(object)_baseTexture);
}
}
[HarmonyPatch(typeof(HUDManager), "Start")]
[HarmonyPostfix]
public static void HUDManagerStartPostfix()
{
_scanRenderer = null;
SetScanColor();
UpdateScanTexture();
}
[HarmonyPatch(typeof(HUDManager), "Update")]
[HarmonyPostfix]
public static void HUDManagerUpdatePostfix()
{
if (Config.Instance.FadeOut.Value && HUDManager.Instance.playerPingingScan > -1f)
{
SetScanColorAlpha(ScanProgress * Config.Instance.Alpha.Value);
}
}
[HarmonyPatch(typeof(HUDManager), "PingScan_performed")]
[HarmonyPrefix]
public static void HUDManagerPingScanPerformedPrefix(CallbackContext context)
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
if (Config.Instance.RandomColor.Value && HUDManager.Instance.CanPlayerScan())
{
SetScanColor(RandomColor);
}
}
}
[BepInPlugin("Niro.ScanRecolor", "ScanRecolor", "1.1.5")]
public class Plugin : BaseUnityPlugin
{
public const string modGUID = "Niro.ScanRecolor";
public const string modName = "ScanRecolor";
public const string modVersion = "1.1.5";
private readonly Harmony harmony = new Harmony("Niro.ScanRecolor");
private static Plugin instance;
internal static ManualLogSource mls;
public static ConfigFile BepInExConfig()
{
return ((BaseUnityPlugin)instance).Config;
}
public void Awake()
{
if (instance == null)
{
instance = this;
}
mls = Logger.CreateLogSource("Niro.ScanRecolor");
Config.Instance.Setup();
mls.LogMessage((object)"Plugin ScanRecolor loaded!");
harmony.PatchAll(typeof(HUDManagerPatch));
}
}
internal class Utils
{
public static Texture MakeTextureReadable(Texture original)
{
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Expected O, but got Unknown
RenderTexture temporary = RenderTexture.GetTemporary(original.width, original.height, 0, (RenderTextureFormat)7, (RenderTextureReadWrite)1);
Graphics.Blit(original, temporary);
RenderTexture active = RenderTexture.active;
RenderTexture.active = temporary;
Texture2D val = new Texture2D(original.width, original.height);
val.ReadPixels(new Rect(0f, 0f, (float)((Texture)temporary).width, (float)((Texture)temporary).height), 0, 0);
val.Apply();
RenderTexture.active = active;
RenderTexture.ReleaseTemporary(temporary);
return (Texture)val;
}
public static void RecolorTexture(ref Texture2D texture, Color color)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
float num = color.r + color.g + color.b;
List<Color> list = texture.GetPixels().ToList();
Plugin.mls.LogDebug((object)("ScanTexture pixel count: " + list.Count));
for (int num2 = list.Count - 1; num2 >= 0; num2--)
{
float num3 = list[num2].r + list[num2].g + list[num2].b;
if (!(num3 < 0.05f) && !(list[num2].a < 0.05f))
{
float num4 = ((num == 0f) ? 0f : (num3 / num));
list[num2] = new Color(color.r * num4, color.g * num4, color.b * num4);
}
}
texture.SetPixels(list.ToArray());
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
