using System;
using System.Collections;
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.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("Omniscye")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("InternalError")]
[assembly: AssemblyTitle("InternalError")]
[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.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;
}
}
[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 Empress.RepoMods.ShaderShenanigans
{
[BepInPlugin("empress.repo.shader-shenanigans", "ShaderShenanigans", "1.0.0")]
public class ShaderShenanigansPlugin : BaseUnityPlugin
{
public enum ModeOption
{
NonePink,
CursedUnlit
}
[CompilerGenerated]
private sealed class <GetAllRenderable>d__22 : IEnumerable<Renderer>, IEnumerable, IEnumerator<Renderer>, IEnumerator, IDisposable
{
private int <>1__state;
private Renderer <>2__current;
private int <>l__initialThreadId;
public ShaderShenanigansPlugin <>4__this;
private Renderer[] <renderers>5__1;
private Renderer[] <>s__2;
private int <>s__3;
private Renderer <r>5__4;
Renderer IEnumerator<Renderer>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <GetAllRenderable>d__22(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<renderers>5__1 = null;
<>s__2 = null;
<r>5__4 = null;
<>1__state = -2;
}
private bool MoveNext()
{
int num = <>1__state;
if (num != 0)
{
if (num != 1)
{
return false;
}
<>1__state = -1;
<r>5__4 = null;
goto IL_00be;
}
<>1__state = -1;
<renderers>5__1 = Resources.FindObjectsOfTypeAll<Renderer>();
<>s__2 = <renderers>5__1;
<>s__3 = 0;
goto IL_00cc;
IL_00be:
<>s__3++;
goto IL_00cc;
IL_00cc:
if (<>s__3 < <>s__2.Length)
{
<r>5__4 = <>s__2[<>s__3];
if ((Object)(object)<r>5__4 == (Object)null || <>4__this._ignoredRenderers.Contains(<r>5__4) || IsUIOrShouldIgnore(<r>5__4))
{
goto IL_00be;
}
<>2__current = <r>5__4;
<>1__state = 1;
return true;
}
<>s__2 = null;
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<Renderer> IEnumerable<Renderer>.GetEnumerator()
{
<GetAllRenderable>d__22 result;
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
result = this;
}
else
{
result = new <GetAllRenderable>d__22(0)
{
<>4__this = <>4__this
};
}
return result;
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<Renderer>)this).GetEnumerator();
}
}
public const string PluginGuid = "empress.repo.shader-shenanigans";
public const string PluginName = "ShaderShenanigans";
public const string PluginVersion = "1.0.0";
private static ManualLogSource _log;
private ConfigEntry<ModeOption> _mode;
private ConfigEntry<bool> _applyOnSceneLoad;
private ConfigEntry<bool> _autoReapplyEachLoadCycle;
private ConfigEntry<bool> _touchSkybox;
private ConfigEntry<bool> _duplicateMaterialsPerRenderer;
private ConfigEntry<KeyboardShortcut> _applyHotkey;
private ConfigEntry<KeyboardShortcut> _restoreHotkey;
private readonly Dictionary<Material, Shader> _originalShaders = new Dictionary<Material, Shader>(256);
private readonly HashSet<Renderer> _ignoredRenderers = new HashSet<Renderer>();
private Material _savedSkybox;
private Shader _errorShader;
private Shader _unlitColorShader;
private void Awake()
{
//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
_log = ((BaseUnityPlugin)this).Logger;
_mode = ((BaseUnityPlugin)this).Config.Bind<ModeOption>("General", "Mode", ModeOption.NonePink, "NonePink: everything turns hot-pink (Hidden/InternalErrorShader). CursedUnlit: everything becomes Unlit/Color with randomized tints.");
_applyOnSceneLoad = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ApplyOnSceneLoad", true, "Apply automatically each time a scene finishes loading.");
_autoReapplyEachLoadCycle = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ReapplyAfterRestore", false, "If true, re-apply on each scene load even if you restored previously.");
_touchSkybox = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "AffectSkybox", false, "If true, also replace RenderSettings.skybox.");
_duplicateMaterialsPerRenderer = ((BaseUnityPlugin)this).Config.Bind<bool>("Advanced", "DuplicatePerRenderer", false, "If true, swaps operate on per-renderer material instances (renderer.materials) instead of shared materials. Costs memory, but isolates effects.");
_applyHotkey = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Hotkeys", "ApplyHotkey", new KeyboardShortcut((KeyCode)288, Array.Empty<KeyCode>()), "Press to apply shader swap to the current scene.");
_restoreHotkey = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Hotkeys", "RestoreHotkey", new KeyboardShortcut((KeyCode)289, Array.Empty<KeyCode>()), "Press to restore all original shaders.");
SceneManager.sceneLoaded += OnSceneLoaded;
_errorShader = Shader.Find("Hidden/InternalErrorShader");
_unlitColorShader = Shader.Find("Unlit/Color");
if ((Object)(object)_errorShader == (Object)null)
{
_log.LogWarning((object)"Hidden/InternalErrorShader not found (unexpected). Pink mode may not work on this Unity build.");
}
if ((Object)(object)_unlitColorShader == (Object)null)
{
_log.LogWarning((object)"Unlit/Color not found. CursedUnlit will try Unlit/Texture as fallback.");
}
}
private void OnDestroy()
{
SceneManager.sceneLoaded -= OnSceneLoaded;
}
private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
if (_applyOnSceneLoad.Value)
{
try
{
Apply();
}
catch (Exception arg)
{
_log.LogError((object)$"Apply on scene load failed: {arg}");
}
}
}
private void Update()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: 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)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
KeyboardShortcut value = _applyHotkey.Value;
if (((KeyboardShortcut)(ref value)).IsDown())
{
Apply();
}
value = _restoreHotkey.Value;
if (((KeyboardShortcut)(ref value)).IsDown())
{
Restore();
}
}
private static bool IsUIOrShouldIgnore(Renderer r)
{
//IL_0011: 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_0019: Invalid comparison between Unknown and I4
if ((Object)(object)r == (Object)null)
{
return true;
}
if ((((Object)r).hideFlags & 1) > 0)
{
return true;
}
if (!((Component)r).gameObject.activeInHierarchy)
{
return true;
}
if ((Object)(object)((Component)r).GetComponentInParent<Canvas>(true) != (Object)null)
{
return true;
}
return false;
}
[IteratorStateMachine(typeof(<GetAllRenderable>d__22))]
private IEnumerable<Renderer> GetAllRenderable()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <GetAllRenderable>d__22(-2)
{
<>4__this = this
};
}
private void Apply()
{
//IL_025e: Unknown result type (might be due to invalid IL or missing references)
int num = 0;
int num2 = 0;
foreach (Renderer item in GetAllRenderable())
{
try
{
Material[] array = (_duplicateMaterialsPerRenderer.Value ? item.materials : item.sharedMaterials);
if (array == null || array.Length == 0)
{
continue;
}
foreach (Material val in array)
{
if ((Object)(object)val == (Object)null)
{
continue;
}
if (!_originalShaders.ContainsKey(val))
{
_originalShaders[val] = val.shader;
}
switch (_mode.Value)
{
case ModeOption.NonePink:
if ((Object)(object)_errorShader != (Object)null)
{
val.shader = _errorShader;
}
break;
case ModeOption.CursedUnlit:
ApplyUnlitCursed(val);
break;
}
num++;
}
if (_duplicateMaterialsPerRenderer.Value)
{
item.materials = array;
}
num2++;
}
catch (Exception ex)
{
_ignoredRenderers.Add(item);
_log.LogWarning((object)("Renderer " + ((Object)item).name + " caused an exception and will be ignored this session: " + ex.Message));
}
}
if (_touchSkybox.Value)
{
try
{
if ((Object)(object)_savedSkybox == (Object)null)
{
_savedSkybox = RenderSettings.skybox;
}
if ((Object)(object)_savedSkybox != (Object)null)
{
switch (_mode.Value)
{
case ModeOption.NonePink:
if ((Object)(object)_errorShader != (Object)null)
{
_savedSkybox.shader = _errorShader;
}
break;
case ModeOption.CursedUnlit:
if ((Object)(object)_unlitColorShader != (Object)null)
{
_savedSkybox.shader = _unlitColorShader;
if (_savedSkybox.HasProperty("_Color"))
{
_savedSkybox.SetColor("_Color", Random.ColorHSV());
}
}
else
{
Shader val2 = Shader.Find("Unlit/Texture");
if ((Object)(object)val2 != (Object)null)
{
_savedSkybox.shader = val2;
}
}
break;
}
RenderSettings.skybox = _savedSkybox;
}
}
catch (Exception ex2)
{
_log.LogWarning((object)("Skybox swap failed: " + ex2.Message));
}
}
_log.LogInfo((object)$"ShaderShenanigans applied. Renderers: {num2}, Materials touched: {num}. Mode={_mode.Value}");
}
private void ApplyUnlitCursed(Material m)
{
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)m == (Object)null)
{
return;
}
if ((Object)(object)_unlitColorShader != (Object)null)
{
m.shader = _unlitColorShader;
if (m.HasProperty("_Color"))
{
m.SetColor("_Color", Random.ColorHSV(0f, 1f, 0.6f, 1f, 0.6f, 1f));
}
}
else
{
Shader val = Shader.Find("Unlit/Texture");
if ((Object)(object)val != (Object)null)
{
m.shader = val;
}
}
}
private void Restore()
{
int num = 0;
KeyValuePair<Material, Shader>[] array = _originalShaders.ToArray();
for (int i = 0; i < array.Length; i++)
{
KeyValuePair<Material, Shader> keyValuePair = array[i];
Material key = keyValuePair.Key;
Shader value = keyValuePair.Value;
if (!((Object)(object)key == (Object)null))
{
try
{
key.shader = value;
num++;
}
catch (Exception ex)
{
_log.LogWarning((object)("Failed to restore material " + ((Object)key).name + ": " + ex.Message));
}
}
}
_originalShaders.Clear();
if (_touchSkybox.Value && (Object)(object)_savedSkybox != (Object)null)
{
try
{
RenderSettings.skybox = _savedSkybox;
}
catch (Exception ex2)
{
_log.LogWarning((object)("Failed to restore skybox: " + ex2.Message));
}
}
_log.LogInfo((object)$"ShaderShenanigans restored {num} materials.");
}
}
}
namespace InternalError
{
[BepInPlugin("Omniscye.InternalError", "InternalError", "1.0")]
public class InternalError : BaseUnityPlugin
{
internal static InternalError Instance { get; private set; }
internal static ManualLogSource Logger => Instance._logger;
private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;
internal Harmony? Harmony { get; set; }
private void Awake()
{
Instance = this;
((Component)this).gameObject.transform.parent = null;
((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
Patch();
Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
}
internal void Patch()
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Expected O, but got Unknown
//IL_0026: Expected O, but got Unknown
if (Harmony == null)
{
Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
Harmony val2 = val;
Harmony = val;
}
Harmony.PatchAll();
}
internal void Unpatch()
{
Harmony? harmony = Harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
private void Update()
{
}
}
}
