using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("ScanRecolorRework")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ScanRecolorRework")]
[assembly: AssemblyCopyright("Copyright © 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("46114aec-931f-4466-b3f9-9e803b580843")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace hoppinhauler.ScanRecolorRework;
[HarmonyPatch]
internal static class HUDManagerPatch
{
private const float ScanDuration = 1.3f;
private static MeshRenderer _scanRenderer;
private static Volume _scanVolume;
private static Vignette _scanVignette;
private static Bloom _scanBloom;
private static Texture2D _baseScanLinesTextureReadable;
private static Color? _currentRandomColor;
private static float _gradientT;
private static FieldInfo _fiPlayerPingingScan;
private static MethodInfo _miCanPlayerScan;
private static bool _applyQueued;
private static bool HasScanMaterial
{
get
{
MeshRenderer scanRenderer = ScanRenderer;
return (Object)(object)scanRenderer != (Object)null && (Object)(object)((Renderer)scanRenderer).material != (Object)null;
}
}
private static MeshRenderer ScanRenderer
{
get
{
if ((Object)(object)_scanRenderer != (Object)null && (Object)(object)((Renderer)_scanRenderer).material != (Object)null)
{
return _scanRenderer;
}
HUDManager instance = HUDManager.Instance;
if ((Object)(object)instance == (Object)null || (Object)(object)instance.scanEffectAnimator == (Object)null)
{
return null;
}
MeshRenderer scanRenderer = default(MeshRenderer);
if (!((Component)instance.scanEffectAnimator).TryGetComponent<MeshRenderer>(ref scanRenderer))
{
return null;
}
_scanRenderer = scanRenderer;
return _scanRenderer;
}
}
private static Volume ScanVolume
{
get
{
if ((Object)(object)_scanVolume != (Object)null)
{
return _scanVolume;
}
try
{
Volume[] array = Object.FindObjectsByType<Volume>((FindObjectsSortMode)0);
if (array != null)
{
_scanVolume = ((IEnumerable<Volume>)array).FirstOrDefault((Func<Volume, bool>)delegate(Volume v)
{
if ((Object)(object)v == (Object)null)
{
return false;
}
VolumeProfile profile = v.profile;
if ((Object)(object)profile == (Object)null)
{
return false;
}
string name = ((Object)profile).name;
return !string.IsNullOrEmpty(name) && name.StartsWith("ScanVolume", StringComparison.OrdinalIgnoreCase);
});
}
}
catch
{
}
return _scanVolume;
}
}
private static Vignette ScanVignette
{
get
{
if ((Object)(object)_scanVignette != (Object)null)
{
return _scanVignette;
}
Volume scanVolume = ScanVolume;
if ((Object)(object)scanVolume == (Object)null || (Object)(object)scanVolume.profile == (Object)null || scanVolume.profile.components == null)
{
return null;
}
VolumeComponent? obj = ((IEnumerable<VolumeComponent>)scanVolume.profile.components).FirstOrDefault((Func<VolumeComponent, bool>)delegate(VolumeComponent c)
{
if ((Object)(object)c == (Object)null)
{
return false;
}
string name = ((Object)c).name;
return !string.IsNullOrEmpty(name) && name.StartsWith("Vignette", StringComparison.OrdinalIgnoreCase);
});
_scanVignette = (Vignette)(object)((obj is Vignette) ? obj : null);
return _scanVignette;
}
}
private static Bloom ScanBloom
{
get
{
if ((Object)(object)_scanBloom != (Object)null)
{
return _scanBloom;
}
Volume scanVolume = ScanVolume;
if ((Object)(object)scanVolume == (Object)null || (Object)(object)scanVolume.profile == (Object)null || scanVolume.profile.components == null)
{
return null;
}
VolumeComponent? obj = ((IEnumerable<VolumeComponent>)scanVolume.profile.components).FirstOrDefault((Func<VolumeComponent, bool>)delegate(VolumeComponent c)
{
if ((Object)(object)c == (Object)null)
{
return false;
}
string name = ((Object)c).name;
return !string.IsNullOrEmpty(name) && name.StartsWith("Bloom", StringComparison.OrdinalIgnoreCase);
});
_scanBloom = (Bloom)(object)((obj is Bloom) ? obj : null);
return _scanBloom;
}
}
internal static void RequestApply()
{
_applyQueued = true;
ApplyAllIfPossible();
}
private static bool TryGetPlayerPingingScan(out float value)
{
value = -1f;
HUDManager instance = HUDManager.Instance;
if ((Object)(object)instance == (Object)null)
{
return false;
}
try
{
if (_fiPlayerPingingScan == null)
{
_fiPlayerPingingScan = typeof(HUDManager).GetField("playerPingingScan", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
}
if (_fiPlayerPingingScan == null)
{
return false;
}
object value2 = _fiPlayerPingingScan.GetValue(instance);
if (value2 is float)
{
float num = (float)value2;
if (true)
{
value = num;
return true;
}
}
}
catch
{
}
return false;
}
private static bool IsScanActive()
{
float value;
return TryGetPlayerPingingScan(out value) && value > -1f;
}
private static float ScanProgress01()
{
if (!TryGetPlayerPingingScan(out var value))
{
return 0f;
}
float num = (value + 1f) / 1.3f;
if (num < 0f)
{
num = 0f;
}
if (num > 1f)
{
num = 1f;
}
return num;
}
private static bool CanPlayerScanSafe()
{
HUDManager instance = HUDManager.Instance;
if ((Object)(object)instance == (Object)null)
{
return false;
}
try
{
if (_miCanPlayerScan == null)
{
_miCanPlayerScan = AccessTools.Method(typeof(HUDManager), "CanPlayerScan", (Type[])null, (Type[])null);
}
if (_miCanPlayerScan == null)
{
return false;
}
object obj = _miCanPlayerScan.Invoke(instance, null);
bool flag = default(bool);
int num;
if (obj is bool)
{
flag = (bool)obj;
num = 1;
}
else
{
num = 0;
}
return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
}
catch
{
return false;
}
}
private static Color GetEffectiveScanColor(bool includeAnimatedAlpha)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: 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_0029: 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_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: 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)
//IL_0124: 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_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_011f: Unknown result type (might be due to invalid IL or missing references)
//IL_0120: Unknown result type (might be due to invalid IL or missing references)
//IL_0117: Unknown result type (might be due to invalid IL or missing references)
//IL_011c: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Unknown result type (might be due to invalid IL or missing references)
//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
//IL_0224: Unknown result type (might be due to invalid IL or missing references)
//IL_0234: Unknown result type (might be due to invalid IL or missing references)
//IL_0239: Unknown result type (might be due to invalid IL or missing references)
//IL_023a: Unknown result type (might be due to invalid IL or missing references)
//IL_023b: Unknown result type (might be due to invalid IL or missing references)
//IL_0144: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00c7: 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_023f: Unknown result type (might be due to invalid IL or missing references)
Color baseScanColor = ModConfig.GetBaseScanColor();
Color c = baseScanColor;
if (ModConfig.RandomModePerScan.Value == RandomMode.Gradient)
{
Color val = ResolveColorOrFallback(ModConfig.GradientA.Value, baseScanColor);
Color val2 = ResolveColorOrFallback(ModConfig.GradientB.Value, baseScanColor);
float value = ModConfig.GradientSpeed.Value;
if (value <= 0f)
{
c = val;
}
else
{
_gradientT += Time.deltaTime * value;
float gradientT = _gradientT;
float num = gradientT - (float)Math.Floor(gradientT);
if (ModConfig.GradientPingPong.Value)
{
float num2 = ((num < 0.5f) ? (num * 2f) : (2f - num * 2f));
c = Color.Lerp(val, val2, num2);
}
else
{
c = Color.Lerp(val, val2, num);
}
}
c.a = baseScanColor.a;
}
else if (ModConfig.RandomModePerScan.Value != 0)
{
c = ((!_currentRandomColor.HasValue) ? baseScanColor : _currentRandomColor.Value);
}
c.a = baseScanColor.a;
if (includeAnimatedAlpha && IsScanActive())
{
float num3 = baseScanColor.a;
if (ModConfig.FadeEnabled.Value)
{
float x = ScanProgress01();
num3 *= ModConfig.ApplyCurve(x, ModConfig.FadeCurveMode.Value);
}
if (ModConfig.PulseEnabled.Value)
{
float value2 = ModConfig.PulseStrength.Value;
float value3 = ModConfig.PulseSpeed.Value;
if (value2 > 0f && value3 > 0f)
{
float num4 = (float)(Math.Sin((double)(Time.time * value3) * Math.PI * 2.0) * 0.5 + 0.5);
float num5 = 1f - value2 + value2 * num4;
num3 *= num5;
}
}
c.a = ModConfig.Clamp01(num3);
}
return ModConfig.ApplyMaxBrightness(c, ModConfig.Clamp01(ModConfig.MaxBrightness.Value));
}
private static Color ResolveColorOrFallback(string s, Color fallback)
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
if (ModConfig.TryParseColorString(s, out var color))
{
return color;
}
return fallback;
}
private static Color BuildRandomFull()
{
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
Color result = default(Color);
((Color)(ref result))..ctor(Random.Range(0f, 1f), Random.Range(0f, 1f), Random.Range(0f, 1f), 1f);
result.a = ModConfig.ResolveRandomAlpha();
return result;
}
private static Color BuildRandomHueOnly()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
Color baseScanColor = ModConfig.GetBaseScanColor();
float num = default(float);
float num2 = default(float);
float num3 = default(float);
Color.RGBToHSV(baseScanColor, ref num, ref num2, ref num3);
float num4 = ModConfig.RandomHueJitter.Value / 360f;
float num5 = Random.Range(0f - num4, num4);
float num6 = ModConfig.Clamp01(ModConfig.RandomSVJitter.Value);
float num7 = Random.Range(0f - num6, num6);
float num8 = Random.Range(0f - num6, num6);
float num9;
for (num9 = num + num5; num9 < 0f; num9 += 1f)
{
}
while (num9 > 1f)
{
num9 -= 1f;
}
float num10 = ModConfig.Clamp01(num2 + num7);
float num11 = ModConfig.Clamp01(num3 + num8);
Color result = Color.HSVToRGB(num9, num10, num11);
result.a = ModConfig.ResolveRandomAlpha();
return result;
}
private static Color BuildRandomFromPalette()
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: 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)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
List<Color> list = ModConfig.ParsePaletteOrFallback();
int index = Random.Range(0, list.Count);
Color result = list[index];
result.a = ModConfig.ResolveRandomAlpha();
return result;
}
private static void ApplyAllIfPossible()
{
//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_0039: 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_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
if (ModConfig.Enabled.Value)
{
if ((Object)(object)ScanRenderer == (Object)null)
{
_applyQueued = true;
return;
}
_applyQueued = false;
Color effectiveScanColor = GetEffectiveScanColor(includeAnimatedAlpha: true);
ApplyScanOverlayColor(effectiveScanColor);
ApplyVignette(effectiveScanColor);
ApplyBloom(effectiveScanColor);
ApplyScanLines(effectiveScanColor);
}
}
private static void ApplyScanOverlayColor(Color col)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
if (!HasScanMaterial)
{
return;
}
try
{
((Renderer)ScanRenderer).material.color = col;
}
catch
{
}
}
private static void ApplyVignette(Color scanColor)
{
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: 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_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
if (!ModConfig.VignetteEnabled.Value)
{
return;
}
Vignette scanVignette = ScanVignette;
if ((Object)(object)scanVignette == (Object)null)
{
return;
}
try
{
((VolumeParameter<float>)(object)scanVignette.intensity).value = ModConfig.VignetteIntensity.Value;
Color value;
if (ModConfig.VignetteUseScanColor.Value)
{
value = scanColor;
value.a = 1f;
}
else
{
value = ResolveColorOrFallback(ModConfig.VignetteColor.Value, scanColor);
value.a = ModConfig.Clamp01(ModConfig.VignetteAlpha.Value);
}
((VolumeParameter<Color>)(object)scanVignette.color).value = value;
}
catch
{
}
}
private static void ApplyBloom(Color scanColor)
{
//IL_004d: 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)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
if (!ModConfig.BloomEnabled.Value)
{
return;
}
Bloom scanBloom = ScanBloom;
if ((Object)(object)scanBloom == (Object)null)
{
return;
}
try
{
Color val = (ModConfig.BloomUseScanColor.Value ? scanColor : ResolveColorOrFallback(ModConfig.BloomColor.Value, scanColor));
val.a = ModConfig.Clamp01(ModConfig.BloomAlpha.Value);
float value = ModConfig.BloomTintStrength.Value;
val.r = ModConfig.Clamp01(val.r * value);
val.g = ModConfig.Clamp01(val.g * value);
val.b = ModConfig.Clamp01(val.b * value);
((VolumeParameter<Color>)(object)scanBloom.tint).Override(val);
}
catch
{
}
}
private static void ApplyScanLines(Color scanColor)
{
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
//IL_00e0: Expected O, but got Unknown
//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
if (!ModConfig.ScanLinesEnabled.Value)
{
return;
}
Bloom scanBloom = ScanBloom;
if ((Object)(object)scanBloom == (Object)null || (VolumeParameter<Texture>)(object)scanBloom.dirtTexture == (Texture)null)
{
return;
}
if (!ModConfig.RecolorScanLines.Value)
{
RevertScanLinesTexture();
return;
}
try
{
EnsureBaseScanLinesReadable();
if (!((Object)(object)_baseScanLinesTextureReadable == (Object)null) && ((Texture)_baseScanLinesTextureReadable).isReadable)
{
float num = ModConfig.Clamp01(ModConfig.ScanLinesRecolorStrength.Value);
if (num <= 0.001f)
{
RevertScanLinesTexture();
return;
}
Texture2D val = new Texture2D(((Texture)_baseScanLinesTextureReadable).width, ((Texture)_baseScanLinesTextureReadable).height, _baseScanLinesTextureReadable.format, false);
val.SetPixels(_baseScanLinesTextureReadable.GetPixels());
val.Apply(false, false);
TextureUtils.RecolorTextureInPlace(val, scanColor, num, ModConfig.Clamp01(ModConfig.ScanLinesMinLuma.Value), ModConfig.Clamp01(ModConfig.ScanLinesMinAlpha.Value));
val.Apply(false, false);
((VolumeParameter<Texture>)(object)scanBloom.dirtTexture).Override((Texture)(object)Object.Instantiate<Texture2D>(val));
}
}
catch
{
}
}
private static void EnsureBaseScanLinesReadable()
{
if ((Object)(object)_baseScanLinesTextureReadable != (Object)null)
{
return;
}
Bloom scanBloom = ScanBloom;
if ((Object)(object)scanBloom == (Object)null || (VolumeParameter<Texture>)(object)scanBloom.dirtTexture == (Texture)null)
{
return;
}
try
{
Texture value = ((VolumeParameter<Texture>)(object)scanBloom.dirtTexture).value;
if (!((Object)(object)value == (Object)null))
{
Texture2D val = (Texture2D)(object)((value is Texture2D) ? value : null);
if ((Object)(object)val != (Object)null && ((Texture)val).isReadable)
{
_baseScanLinesTextureReadable = val;
}
else
{
_baseScanLinesTextureReadable = TextureUtils.MakeReadableTexture(value);
}
}
}
catch
{
}
}
private static void RevertScanLinesTexture()
{
try
{
Bloom scanBloom = ScanBloom;
if (!((Object)(object)scanBloom == (Object)null) && !((VolumeParameter<Texture>)(object)scanBloom.dirtTexture == (Texture)null) && (Object)(object)_baseScanLinesTextureReadable != (Object)null)
{
((VolumeParameter<Texture>)(object)scanBloom.dirtTexture).Override((Texture)(object)_baseScanLinesTextureReadable);
}
}
catch
{
}
}
[HarmonyPatch(typeof(HUDManager), "Start")]
[HarmonyPostfix]
private static void HUDStartPostfix()
{
_scanRenderer = null;
_scanVolume = null;
_scanVignette = null;
_scanBloom = null;
_fiPlayerPingingScan = null;
_miCanPlayerScan = null;
_currentRandomColor = null;
_gradientT = 0f;
_applyQueued = true;
ApplyAllIfPossible();
}
[HarmonyPatch(typeof(HUDManager), "Update")]
[HarmonyPostfix]
private static void HUDUpdatePostfix()
{
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: 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_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
if (ModConfig.Enabled.Value)
{
if (_applyQueued && Time.frameCount % 10 == 0)
{
ApplyAllIfPossible();
}
if (IsScanActive())
{
Color effectiveScanColor = GetEffectiveScanColor(includeAnimatedAlpha: true);
ApplyScanOverlayColor(effectiveScanColor);
ApplyVignette(effectiveScanColor);
ApplyBloom(effectiveScanColor);
}
}
}
[HarmonyPatch(typeof(HUDManager), "Awake")]
[HarmonyPostfix]
private static void HUDAwakePostfix()
{
ResetForNewHudInstance();
}
[HarmonyPatch(typeof(HUDManager), "OnEnable")]
[HarmonyPostfix]
private static void HUDOnEnablePostfix()
{
ResetForNewHudInstance();
}
private static void ResetForNewHudInstance()
{
_scanRenderer = null;
_scanVolume = null;
_scanVignette = null;
_scanBloom = null;
_fiPlayerPingingScan = null;
_miCanPlayerScan = null;
_currentRandomColor = null;
_gradientT = 0f;
_applyQueued = true;
ApplyAllIfPossible();
}
[HarmonyPatch(typeof(HUDManager), "PingScan_performed")]
[HarmonyPrefix]
private static void PingScanPerformedPrefix(object __0)
{
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
if (ModConfig.Enabled.Value && CanPlayerScanSafe())
{
switch (ModConfig.RandomModePerScan.Value)
{
case RandomMode.Off:
_currentRandomColor = null;
break;
case RandomMode.Full:
_currentRandomColor = BuildRandomFull();
break;
case RandomMode.HueOnly:
_currentRandomColor = BuildRandomHueOnly();
break;
case RandomMode.Palette:
_currentRandomColor = BuildRandomFromPalette();
break;
case RandomMode.Gradient:
_currentRandomColor = null;
_gradientT = 0f;
break;
}
_applyQueued = true;
ApplyAllIfPossible();
}
}
}
internal enum ColorMode
{
Preset,
RGB,
HSV
}
internal enum RandomMode
{
Off,
Full,
HueOnly,
Palette,
Gradient
}
internal enum FadeCurve
{
Linear,
EaseIn,
EaseOut,
EaseInOut,
Exponential
}
internal static class ModConfig
{
public static ConfigEntry<bool> Enabled;
public static ConfigEntry<bool> ResetOnSceneLoad;
public static ConfigEntry<ColorMode> BaseColorMode;
public static ConfigEntry<string> Preset;
public static ConfigEntry<int> Red;
public static ConfigEntry<int> Green;
public static ConfigEntry<int> Blue;
public static ConfigEntry<float> Hue;
public static ConfigEntry<float> Saturation;
public static ConfigEntry<float> Value;
public static ConfigEntry<float> Alpha;
public static ConfigEntry<float> MaxBrightness;
public static ConfigEntry<RandomMode> RandomModePerScan;
public static ConfigEntry<bool> RandomFixedAlpha;
public static ConfigEntry<float> RandomAlpha;
public static ConfigEntry<float> RandomAlphaMin;
public static ConfigEntry<float> RandomAlphaMax;
public static ConfigEntry<string> RandomPalette;
public static ConfigEntry<float> RandomHueJitter;
public static ConfigEntry<float> RandomSVJitter;
public static ConfigEntry<string> GradientA;
public static ConfigEntry<string> GradientB;
public static ConfigEntry<float> GradientSpeed;
public static ConfigEntry<bool> GradientPingPong;
public static ConfigEntry<bool> FadeEnabled;
public static ConfigEntry<FadeCurve> FadeCurveMode;
public static ConfigEntry<bool> PulseEnabled;
public static ConfigEntry<float> PulseSpeed;
public static ConfigEntry<float> PulseStrength;
public static ConfigEntry<bool> VignetteEnabled;
public static ConfigEntry<float> VignetteIntensity;
public static ConfigEntry<bool> VignetteUseScanColor;
public static ConfigEntry<string> VignetteColor;
public static ConfigEntry<float> VignetteAlpha;
public static ConfigEntry<bool> BloomEnabled;
public static ConfigEntry<float> BloomTintStrength;
public static ConfigEntry<bool> BloomUseScanColor;
public static ConfigEntry<string> BloomColor;
public static ConfigEntry<float> BloomAlpha;
public static ConfigEntry<bool> ScanLinesEnabled;
public static ConfigEntry<bool> RecolorScanLines;
public static ConfigEntry<float> ScanLinesRecolorStrength;
public static ConfigEntry<float> ScanLinesMinLuma;
public static ConfigEntry<float> ScanLinesMinAlpha;
private static readonly Dictionary<string, string> Presets = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
{
{ "Cyan", "#00E5FFFF" },
{ "Green", "#00FF55FF" },
{ "Red", "#FF2A2AFF" },
{ "Purple", "#B000FFFF" },
{ "Amber", "#FFB000FF" },
{ "White", "#FFFFFFFF" },
{ "Pink", "#FF4FD8FF" },
{ "Default", "#000CFFFF" }
};
public static void Bind(ConfigFile cfg)
{
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Expected O, but got Unknown
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00d2: Expected O, but got Unknown
//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
//IL_0107: Expected O, but got Unknown
//IL_0136: Unknown result type (might be due to invalid IL or missing references)
//IL_0140: Expected O, but got Unknown
//IL_016f: Unknown result type (might be due to invalid IL or missing references)
//IL_0179: Expected O, but got Unknown
//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
//IL_01b2: Expected O, but got Unknown
//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
//IL_01eb: Expected O, but got Unknown
//IL_021a: Unknown result type (might be due to invalid IL or missing references)
//IL_0224: Expected O, but got Unknown
//IL_0289: Unknown result type (might be due to invalid IL or missing references)
//IL_0293: Expected O, but got Unknown
//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
//IL_02cc: Expected O, but got Unknown
//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0305: Expected O, but got Unknown
//IL_0353: Unknown result type (might be due to invalid IL or missing references)
//IL_035d: Expected O, but got Unknown
//IL_038c: Unknown result type (might be due to invalid IL or missing references)
//IL_0396: Expected O, but got Unknown
//IL_0403: Unknown result type (might be due to invalid IL or missing references)
//IL_040d: Expected O, but got Unknown
//IL_04a8: Unknown result type (might be due to invalid IL or missing references)
//IL_04b2: Expected O, but got Unknown
//IL_04e1: Unknown result type (might be due to invalid IL or missing references)
//IL_04eb: Expected O, but got Unknown
//IL_0535: Unknown result type (might be due to invalid IL or missing references)
//IL_053f: Expected O, but got Unknown
//IL_05a8: Unknown result type (might be due to invalid IL or missing references)
//IL_05b2: Expected O, but got Unknown
//IL_05fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0606: Expected O, but got Unknown
//IL_066f: Unknown result type (might be due to invalid IL or missing references)
//IL_0679: Expected O, but got Unknown
//IL_06de: Unknown result type (might be due to invalid IL or missing references)
//IL_06e8: Expected O, but got Unknown
//IL_0717: Unknown result type (might be due to invalid IL or missing references)
//IL_0721: Expected O, but got Unknown
//IL_0750: Unknown result type (might be due to invalid IL or missing references)
//IL_075a: Expected O, but got Unknown
Enabled = cfg.Bind<bool>("General", "Enabled", true, "Enable/disable the mod.");
ResetOnSceneLoad = cfg.Bind<bool>("General", "ResetOnSceneLoad", true, "Reset cached references when a scene loads (recommended).");
BaseColorMode = cfg.Bind<ColorMode>("Color", "Mode", ColorMode.Preset, "Base color mode: Preset / RGB / HSV.");
Preset = cfg.Bind<string>("Color", "Preset", "White", "Preset name (Cyan, Green, Red, Purple, Amber, White) or hex (#RRGGBB / #RRGGBBAA).");
Red = cfg.Bind<int>("Color.RGB", "Red", 0, new ConfigDescription("Red channel (0..255).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 255), new object[0]));
Green = cfg.Bind<int>("Color.RGB", "Green", 229, new ConfigDescription("Green channel (0..255).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 255), new object[0]));
Blue = cfg.Bind<int>("Color.RGB", "Blue", 255, new ConfigDescription("Blue channel (0..255).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 255), new object[0]));
Hue = cfg.Bind<float>("Color.HSV", "Hue", 190f, new ConfigDescription("Hue (0..360).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 360f), new object[0]));
Saturation = cfg.Bind<float>("Color.HSV", "Saturation", 1f, new ConfigDescription("Saturation (0..1).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[0]));
Value = cfg.Bind<float>("Color.HSV", "Value", 1f, new ConfigDescription("Value/Brightness (0..1).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[0]));
Alpha = cfg.Bind<float>("Color", "Alpha", 0.5636086f, new ConfigDescription("Scan overlay alpha/opacity (0..1).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[0]));
MaxBrightness = cfg.Bind<float>("Color", "MaxBrightness", 1f, new ConfigDescription("Clamp overall brightness (0..1).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[0]));
RandomModePerScan = cfg.Bind<RandomMode>("Random", "Mode", RandomMode.HueOnly, "Random color per scan: Off / Full / HueOnly / Palette / Gradient.");
RandomFixedAlpha = cfg.Bind<bool>("Random", "FixedAlpha", true, "Use fixed alpha for random colors (otherwise AlphaMin..AlphaMax).");
RandomAlpha = cfg.Bind<float>("Random", "Alpha", 0.26f, new ConfigDescription("Fixed random alpha (0..1).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[0]));
RandomAlphaMin = cfg.Bind<float>("Random", "AlphaMin", 0.26f, new ConfigDescription("Min random alpha when FixedAlpha=false (0..1).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[0]));
RandomAlphaMax = cfg.Bind<float>("Random", "AlphaMax", 0.65f, new ConfigDescription("Max random alpha when FixedAlpha=false (0..1).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[0]));
RandomPalette = cfg.Bind<string>("Random", "Palette", "Cyan, Purple, Green, Amber", "Palette for Random=Palette. Items can be preset names or hex.");
RandomHueJitter = cfg.Bind<float>("Random", "HueJitter", 9.65953f, new ConfigDescription("Hue jitter in degrees for HueOnly (0..180).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 180f), new object[0]));
RandomSVJitter = cfg.Bind<float>("Random", "SVJitter", 0.02869597f, new ConfigDescription("Small S/V jitter for HueOnly (0..1).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[0]));
GradientA = cfg.Bind<string>("Gradient", "ColorA", "Cyan", "Gradient color A (preset or hex).");
GradientB = cfg.Bind<string>("Gradient", "ColorB", "Purple", "Gradient color B (preset or hex).");
GradientSpeed = cfg.Bind<float>("Gradient", "Speed", 0.6f, new ConfigDescription("Gradient speed in cycles per second (0..5).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 5f), new object[0]));
GradientPingPong = cfg.Bind<bool>("Gradient", "PingPong", true, "Ping-pong between A and B instead of looping.");
FadeEnabled = cfg.Bind<bool>("Fade", "Enabled", false, "Enable fade alpha animation during scan.");
FadeCurveMode = cfg.Bind<FadeCurve>("Fade", "Curve", FadeCurve.EaseOut, "Fade curve: Linear / EaseIn / EaseOut / EaseInOut / Exponential.");
PulseEnabled = cfg.Bind<bool>("Animation", "Pulse", true, "Enable alpha pulsing during scan.");
PulseSpeed = cfg.Bind<float>("Animation", "PulseSpeed", 3.139388f, new ConfigDescription("Pulse frequency in Hz (0..20).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 20f), new object[0]));
PulseStrength = cfg.Bind<float>("Animation", "PulseStrength", 0.2991548f, new ConfigDescription("Pulse strength (0..1).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[0]));
VignetteEnabled = cfg.Bind<bool>("Vignette", "Enabled", true, "Control scan vignette settings.");
VignetteIntensity = cfg.Bind<float>("Vignette", "Intensity", 0.7582871f, new ConfigDescription("Vignette intensity (0..1).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[0]));
VignetteUseScanColor = cfg.Bind<bool>("Vignette", "UseScanColor", true, "Use scan color for vignette color.");
VignetteColor = cfg.Bind<string>("Vignette", "Color", "#00E5FFFF", "Vignette color when UseScanColor=false (preset or hex).");
VignetteAlpha = cfg.Bind<float>("Vignette", "Alpha", 1f, new ConfigDescription("Vignette alpha when UseScanColor=false (0..1).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[0]));
BloomEnabled = cfg.Bind<bool>("Bloom", "Enabled", true, "Control scan bloom tint settings.");
BloomTintStrength = cfg.Bind<float>("Bloom", "TintStrength", 1.511349f, new ConfigDescription("Bloom tint multiplier (0..2).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), new object[0]));
BloomUseScanColor = cfg.Bind<bool>("Bloom", "UseScanColor", true, "Use scan color for bloom tint.");
BloomColor = cfg.Bind<string>("Bloom", "Color", "#00E5FFFF", "Bloom tint color when UseScanColor=false (preset or hex).");
BloomAlpha = cfg.Bind<float>("Bloom", "Alpha", 1f, new ConfigDescription("Bloom tint alpha (0..1).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[0]));
ScanLinesEnabled = cfg.Bind<bool>("ScanLines", "Enabled", true, "Enable/disable scan-lines (bloom dirt texture) handling.");
RecolorScanLines = cfg.Bind<bool>("ScanLines", "Recolor", true, "Recolor scan-lines texture using the scan color.");
ScanLinesRecolorStrength = cfg.Bind<float>("ScanLines", "RecolorStrength", 1f, new ConfigDescription("How strongly to recolor scan-lines (0..1).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[0]));
ScanLinesMinLuma = cfg.Bind<float>("ScanLines", "MinLuma", 0.05f, new ConfigDescription("Minimum pixel brightness threshold to recolor (0..1).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[0]));
ScanLinesMinAlpha = cfg.Bind<float>("ScanLines", "MinAlpha", 0.05f, new ConfigDescription("Minimum pixel alpha threshold to recolor (0..1).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[0]));
HookApplyOnChanges();
}
private static void HookApplyOnChanges()
{
Action apply = HUDManagerPatch.RequestApply;
Enabled.SettingChanged += delegate
{
apply();
};
ResetOnSceneLoad.SettingChanged += delegate
{
apply();
};
BaseColorMode.SettingChanged += delegate
{
apply();
};
Preset.SettingChanged += delegate
{
apply();
};
Red.SettingChanged += delegate
{
apply();
};
Green.SettingChanged += delegate
{
apply();
};
Blue.SettingChanged += delegate
{
apply();
};
Hue.SettingChanged += delegate
{
apply();
};
Saturation.SettingChanged += delegate
{
apply();
};
Value.SettingChanged += delegate
{
apply();
};
Alpha.SettingChanged += delegate
{
apply();
};
MaxBrightness.SettingChanged += delegate
{
apply();
};
RandomModePerScan.SettingChanged += delegate
{
apply();
};
RandomFixedAlpha.SettingChanged += delegate
{
apply();
};
RandomAlpha.SettingChanged += delegate
{
apply();
};
RandomAlphaMin.SettingChanged += delegate
{
apply();
};
RandomAlphaMax.SettingChanged += delegate
{
apply();
};
RandomPalette.SettingChanged += delegate
{
apply();
};
RandomHueJitter.SettingChanged += delegate
{
apply();
};
RandomSVJitter.SettingChanged += delegate
{
apply();
};
GradientA.SettingChanged += delegate
{
apply();
};
GradientB.SettingChanged += delegate
{
apply();
};
GradientSpeed.SettingChanged += delegate
{
apply();
};
GradientPingPong.SettingChanged += delegate
{
apply();
};
FadeEnabled.SettingChanged += delegate
{
apply();
};
FadeCurveMode.SettingChanged += delegate
{
apply();
};
PulseEnabled.SettingChanged += delegate
{
apply();
};
PulseSpeed.SettingChanged += delegate
{
apply();
};
PulseStrength.SettingChanged += delegate
{
apply();
};
VignetteEnabled.SettingChanged += delegate
{
apply();
};
VignetteIntensity.SettingChanged += delegate
{
apply();
};
VignetteUseScanColor.SettingChanged += delegate
{
apply();
};
VignetteColor.SettingChanged += delegate
{
apply();
};
VignetteAlpha.SettingChanged += delegate
{
apply();
};
BloomEnabled.SettingChanged += delegate
{
apply();
};
BloomTintStrength.SettingChanged += delegate
{
apply();
};
BloomUseScanColor.SettingChanged += delegate
{
apply();
};
BloomColor.SettingChanged += delegate
{
apply();
};
BloomAlpha.SettingChanged += delegate
{
apply();
};
ScanLinesEnabled.SettingChanged += delegate
{
apply();
};
RecolorScanLines.SettingChanged += delegate
{
apply();
};
ScanLinesRecolorStrength.SettingChanged += delegate
{
apply();
};
ScanLinesMinLuma.SettingChanged += delegate
{
apply();
};
ScanLinesMinAlpha.SettingChanged += delegate
{
apply();
};
}
internal static bool TryParseColorString(string s, out Color color)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
color = default(Color);
if (string.IsNullOrWhiteSpace(s))
{
return false;
}
string text = s.Trim();
if (Presets.TryGetValue(text, out var value))
{
text = value;
}
if (text.StartsWith("#", StringComparison.Ordinal))
{
return TryParseHex(text, out color);
}
if (text.IndexOf(",") >= 0)
{
return TryParseCsv(text, out color);
}
return false;
}
private static bool TryParseHex(string hex, out Color color)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
color = default(Color);
string text = hex.Trim();
if (!text.StartsWith("#", StringComparison.Ordinal))
{
return false;
}
text = text.Substring(1);
if (text.Length != 6 && text.Length != 8)
{
return false;
}
try
{
byte b = byte.Parse(text.Substring(0, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
byte b2 = byte.Parse(text.Substring(2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
byte b3 = byte.Parse(text.Substring(4, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
byte b4 = byte.MaxValue;
if (text.Length == 8)
{
b4 = byte.Parse(text.Substring(6, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
}
color = new Color((float)(int)b / 255f, (float)(int)b2 / 255f, (float)(int)b3 / 255f, (float)(int)b4 / 255f);
return true;
}
catch
{
return false;
}
}
private static bool TryParseCsv(string csv, out Color color)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_013c: Unknown result type (might be due to invalid IL or missing references)
//IL_0141: Unknown result type (might be due to invalid IL or missing references)
color = default(Color);
string[] array = csv.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (array.Length != 3 && array.Length != 4)
{
return false;
}
float[] array2 = new float[array.Length];
for (int i = 0; i < array.Length; i++)
{
if (!float.TryParse(array[i].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
{
return false;
}
array2[i] = result;
}
bool flag = array2.Take(3).Any((float x) => x > 1f);
float v = (flag ? (array2[0] / 255f) : array2[0]);
float v2 = (flag ? (array2[1] / 255f) : array2[1]);
float v3 = (flag ? (array2[2] / 255f) : array2[2]);
float v4 = 1f;
if (array.Length == 4)
{
v4 = ((array2[3] > 1f) ? (array2[3] / 255f) : array2[3]);
}
color = new Color(Clamp01(v), Clamp01(v2), Clamp01(v3), Clamp01(v4));
return true;
}
internal static Color GetBaseScanColor()
{
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_0105: Unknown result type (might be due to invalid IL or missing references)
//IL_0115: Unknown result type (might be due to invalid IL or missing references)
//IL_011a: Unknown result type (might be due to invalid IL or missing references)
//IL_011b: Unknown result type (might be due to invalid IL or missing references)
//IL_011c: 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)
Color color = default(Color);
switch (BaseColorMode.Value)
{
case ColorMode.RGB:
((Color)(ref color))..ctor((float)Red.Value / 255f, (float)Green.Value / 255f, (float)Blue.Value / 255f, Alpha.Value);
break;
case ColorMode.HSV:
color = Color.HSVToRGB(Clamp01(Hue.Value / 360f), Clamp01(Saturation.Value), Clamp01(Value.Value));
color.a = Alpha.Value;
break;
default:
if (!TryParseColorString(Preset.Value, out color))
{
((Color)(ref color))..ctor(0f, 0.8980392f, 1f, Alpha.Value);
}
color.a = Alpha.Value;
break;
}
color = ApplyMaxBrightness(color, Clamp01(MaxBrightness.Value));
return color;
}
internal static List<Color> ParsePaletteOrFallback()
{
//IL_0049: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
List<Color> list = new List<Color>();
string text = RandomPalette.Value ?? string.Empty;
string[] array = text.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < array.Length; i++)
{
if (TryParseColorString(array[i].Trim(), out var color))
{
list.Add(color);
}
}
if (list.Count == 0)
{
if (TryParseColorString("Cyan", out var color2))
{
list.Add(color2);
}
if (TryParseColorString("Purple", out color2))
{
list.Add(color2);
}
}
return list;
}
internal static float ResolveRandomAlpha()
{
if (RandomFixedAlpha.Value)
{
return Clamp01(RandomAlpha.Value);
}
float num = Clamp01(RandomAlphaMin.Value);
float num2 = Clamp01(RandomAlphaMax.Value);
if (num2 < num)
{
float num3 = num;
num = num2;
num2 = num3;
}
return Random.Range(num, num2);
}
internal static float Clamp01(float v)
{
if (v < 0f)
{
return 0f;
}
if (v > 1f)
{
return 1f;
}
return v;
}
internal static Color ApplyMaxBrightness(Color c, float maxB)
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
if (maxB >= 0.999f)
{
return c;
}
float num = default(float);
float num2 = default(float);
float val = default(float);
Color.RGBToHSV(c, ref num, ref num2, ref val);
val = Math.Min(val, maxB);
Color result = Color.HSVToRGB(num, num2, val);
result.a = c.a;
return result;
}
internal static float ApplyCurve(float x, FadeCurve curve)
{
x = Clamp01(x);
return curve switch
{
FadeCurve.Linear => x,
FadeCurve.EaseIn => x * x,
FadeCurve.EaseOut => 1f - (1f - x) * (1f - x),
FadeCurve.EaseInOut => (x < 0.5f) ? (2f * x * x) : (1f - (float)Math.Pow(-2f * x + 2f, 2.0) / 2f),
FadeCurve.Exponential => (float)Math.Pow(x, 3.0),
_ => x,
};
}
}
[BepInPlugin("HoppinHauler.ScanRecolorPlus", "ScanRecolorPlus", "1.0.0")]
public sealed class Plugin : BaseUnityPlugin
{
public const string PluginGuid = "HoppinHauler.ScanRecolorPlus";
public const string PluginName = "ScanRecolorPlus";
public const string PluginVersion = "1.0.0";
internal static ManualLogSource Log;
internal static Plugin Instance;
private Harmony _harmony;
internal static ConfigFile BepInExConfig()
{
return ((Object)(object)Instance != (Object)null) ? ((BaseUnityPlugin)Instance).Config : null;
}
private void Awake()
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Expected O, but got Unknown
Instance = this;
Log = ((BaseUnityPlugin)this).Logger;
ModConfig.Bind(((BaseUnityPlugin)this).Config);
_harmony = new Harmony("HoppinHauler.ScanRecolorPlus");
_harmony.PatchAll(typeof(HUDManagerPatch));
SceneHooks.Install();
Log.LogInfo((object)"ScanRecolorPlus v1.0.0 loaded.");
}
private void OnDestroy()
{
SceneHooks.Uninstall();
try
{
_harmony.UnpatchSelf();
}
catch
{
}
}
}
internal static class SceneHooks
{
private static bool _installed;
public static void Install()
{
if (!_installed)
{
_installed = true;
SceneManager.sceneLoaded += OnSceneLoaded;
}
}
public static void Uninstall()
{
if (_installed)
{
_installed = false;
SceneManager.sceneLoaded -= OnSceneLoaded;
}
}
private static void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
if (ModConfig.ResetOnSceneLoad.Value)
{
HUDManagerPatch.RequestApply();
}
else
{
HUDManagerPatch.RequestApply();
}
}
}
internal static class TextureUtils
{
public static Texture2D MakeReadableTexture(Texture original)
{
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Expected O, but got Unknown
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)original == (Object)null)
{
return null;
}
RenderTexture val = null;
RenderTexture active = null;
try
{
val = RenderTexture.GetTemporary(original.width, original.height, 0, (RenderTextureFormat)0, (RenderTextureReadWrite)1);
Graphics.Blit(original, val);
active = RenderTexture.active;
RenderTexture.active = val;
Texture2D val2 = new Texture2D(original.width, original.height, (TextureFormat)4, false);
val2.ReadPixels(new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), 0, 0);
val2.Apply(false, false);
return val2;
}
catch
{
return null;
}
finally
{
try
{
RenderTexture.active = active;
}
catch
{
}
try
{
if ((Object)(object)val != (Object)null)
{
RenderTexture.ReleaseTemporary(val);
}
}
catch
{
}
}
}
public static void RecolorTextureInPlace(Texture2D texture, Color targetColor, float strength, float minLuma, float minAlpha)
{
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: 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_009b: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)texture == (Object)null)
{
return;
}
strength = Clamp01(strength);
if (strength <= 0f)
{
return;
}
Color[] pixels;
try
{
pixels = texture.GetPixels();
}
catch
{
return;
}
Color val2 = default(Color);
for (int i = 0; i < pixels.Length; i++)
{
Color val = pixels[i];
if (!(val.a < minAlpha))
{
float num = (val.r + val.g + val.b) / 3f;
if (!(num < minLuma))
{
((Color)(ref val2))..ctor(targetColor.r * num, targetColor.g * num, targetColor.b * num, val.a);
pixels[i] = Color.Lerp(val, val2, strength);
}
}
}
try
{
texture.SetPixels(pixels);
}
catch
{
}
}
private static float Clamp01(float v)
{
if (v < 0f)
{
return 0f;
}
if (v > 1f)
{
return 1f;
}
return v;
}
}
