Decompiled source of FixCameraResolution v1.3.2

Fix Camera Resolution.dll

Decompiled a week ago
using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalConfig.ConfigItems.Options;
using Microsoft.CodeAnalysis;
using Rumi.FixCameraResolutions.Fogs;
using Rumi.FixCameraResolutions.Resolutions;
using Rumi.FixCameraResolutions.Visors;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Fix Camera Resolution")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Fix Camera Resolution")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("dabb3c14-d069-4fdb-87ea-c7169dc3ef9e")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace Rumi.FixCameraResolutions
{
	internal static class Debug
	{
		public static void Log(object data)
		{
			ManualLogSource? logger = FCRPlugin.logger;
			if (logger != null)
			{
				logger.LogInfo(data);
			}
		}

		public static void LogWarning(object data)
		{
			ManualLogSource? logger = FCRPlugin.logger;
			if (logger != null)
			{
				logger.LogWarning(data);
			}
		}

		public static void LogError(object data)
		{
			ManualLogSource? logger = FCRPlugin.logger;
			if (logger != null)
			{
				logger.LogError(data);
			}
		}
	}
	[BepInPlugin("Rumi.FixCameraResolutions", "FixCameraResolutions", "1.3.2")]
	public sealed class FCRPlugin : BaseUnityPlugin
	{
		public const string modGuid = "Rumi.FixCameraResolutions";

		public const string modName = "FixCameraResolutions";

		public const string modVersion = "1.3.2";

		internal static ManualLogSource? logger { get; private set; } = null;


		public static FCRResConfig? resConfig { get; private set; }

		public static FCRHDRPConfig? hdrpConfig { get; private set; }

		public static FCRVisorConfig? visorConfig { get; private set; }

		internal static Harmony harmony { get; } = new Harmony("Rumi.FixCameraResolutions");


		private void Awake()
		{
			logger = ((BaseUnityPlugin)this).Logger;
			Debug.Log("Start loading plugin...");
			resConfig = FCRResConfig.Create(((BaseUnityPlugin)this).Config);
			hdrpConfig = FCRHDRPConfig.Create(((BaseUnityPlugin)this).Config);
			visorConfig = FCRVisorConfig.Create(((BaseUnityPlugin)this).Config);
			if (Type.GetType("LethalConfig.LethalConfigManager, LethalConfig, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null", throwOnError: false) != null)
			{
				try
				{
					Debug.Log("Lethal Config Registration");
					if (resConfig != null)
					{
						FCRResConfig.LethalConfig.Patch(resConfig);
					}
					if (hdrpConfig != null)
					{
						FCRHDRPConfig.LethalConfig.Patch(hdrpConfig);
					}
					if (visorConfig != null)
					{
						FCRVisorConfig.LethalConfig.Patch(visorConfig);
					}
				}
				catch (Exception data)
				{
					Debug.LogError(data);
					Debug.LogWarning("Lethal Config Registration Fail!");
				}
			}
			((BaseUnityPlugin)this).Config.Save();
			Patch();
			Debug.Log("Plugin FixCameraResolutions is loaded!");
		}

		public static void Repatch()
		{
			FCRResPatches.UpdateAll();
			FCRHDRPPatches.UpdateAll();
			FCRVisorPatches.UpdateAllPlayer();
			Unpatch();
			Patch();
		}

		private static void Patch()
		{
			FCRResPatches.Patch();
			FCRHDRPPatches.Patch();
			FCRVisorPatches.Patch();
		}

		private static void Unpatch()
		{
			Debug.Log("Unpatch...");
			try
			{
				harmony.UnpatchSelf();
			}
			catch (Exception data)
			{
				Debug.LogError(data);
				Debug.LogError("Unpatch Fail!");
			}
			Debug.Log("Unpatched!");
		}
	}
	public static class FCRUtility
	{
		public static Vector2 Multiply(this Vector2 position, float x, float y)
		{
			//IL_0000: 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_0010: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(position.x * x, position.y * y);
		}
	}
}
namespace Rumi.FixCameraResolutions.Visors
{
	public sealed class FCRVisorConfig
	{
		public static class LethalConfig
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			public static void Patch(FCRVisorConfig config)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				LethalConfigManager.AddConfigItem((BaseConfigItem)new BoolCheckBoxConfigItem(config._disable, false));
			}
		}

		private readonly ConfigEntry<bool> _disable;

		public const bool dDisable = false;

		public bool disable
		{
			get
			{
				return _disable.Value;
			}
			set
			{
				_disable.Value = value;
			}
		}

		internal static FCRVisorConfig? Create(ConfigFile config)
		{
			Debug.Log("Visor Config Loading...");
			try
			{
				FCRVisorConfig result = new FCRVisorConfig(config);
				Debug.Log("Visor Config Loaded!");
				return result;
			}
			catch (Exception data)
			{
				Debug.LogError(data);
				Debug.LogWarning("Failed to load config file\nSettings will be loaded with defaults!");
			}
			return null;
		}

		private FCRVisorConfig(ConfigFile config)
		{
			_disable = config.Bind<bool>("Visors", "Disable", false, "Disables visor rendering");
			_disable.SettingChanged += delegate
			{
				FCRPlugin.Repatch();
			};
		}
	}
	public static class FCRVisorPatches
	{
		public static bool disable => FCRPlugin.visorConfig?.disable ?? false;

		[HarmonyPatch(typeof(PlayerControllerB), "Start")]
		[HarmonyPostfix]
		private static void PlayerControllerB_Start_Postfix(PlayerControllerB __instance)
		{
			UpdatePlayer(__instance);
		}

		public static void UpdateAllPlayer()
		{
			PlayerControllerB[] array = Object.FindObjectsByType<PlayerControllerB>((FindObjectsSortMode)0);
			for (int i = 0; i < array.Length; i++)
			{
				UpdatePlayer(array[i]);
			}
		}

		public static void UpdatePlayer(PlayerControllerB player)
		{
			if ((Object)(object)player.localVisor != (Object)null)
			{
				((Component)player.localVisor).gameObject.SetActive(!disable);
			}
		}

		internal static void Patch()
		{
			if (!disable)
			{
				return;
			}
			Debug.Log("Visor Patch...");
			try
			{
				FCRPlugin.harmony.PatchAll(typeof(FCRVisorPatches));
				Debug.Log("Visor Patched!");
			}
			catch (Exception data)
			{
				Debug.LogError(data);
				Debug.LogError("Resolution Patch Fail!");
			}
		}
	}
}
namespace Rumi.FixCameraResolutions.Resolutions
{
	public sealed class FCRResConfig
	{
		public static class LethalConfig
		{
			[Serializable]
			[CompilerGenerated]
			private sealed class <>c
			{
				public static readonly <>c <>9 = new <>c();

				public static GenericButtonHandler <>9__0_0;

				internal void <Patch>b__0_0()
				{
					FCRResPatches.UpdateAll();
				}
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			public static void Patch(FCRResConfig config)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: 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_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Expected O, but got Unknown
				//IL_003a: Expected O, but got Unknown
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Expected O, but got Unknown
				//IL_0045: 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)
				//IL_0052: Expected O, but got Unknown
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Expected O, but got Unknown
				//IL_005d: 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_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Expected O, but got Unknown
				//IL_007b: Expected O, but got Unknown
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Expected O, but got Unknown
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Expected O, but got Unknown
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Expected O, but got Unknown
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: 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_00b7: Expected O, but got Unknown
				//IL_00bc: Expected O, but got Unknown
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Expected O, but got Unknown
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Expected O, but got Unknown
				//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_00f4: Expected O, but got Unknown
				LethalConfigManager.AddConfigItem((BaseConfigItem)new BoolCheckBoxConfigItem(config._enable, false));
				LethalConfigManager.AddConfigItem((BaseConfigItem)new BoolCheckBoxConfigItem(config._autoSize, new BoolCheckBoxOptions
				{
					RequiresRestart = false,
					CanModifyCallback = new CanModifyDelegate(CanModifyAutoSize)
				}));
				ConfigEntry<int> width = config._width;
				IntSliderOptions val = new IntSliderOptions();
				((BaseRangeOptions<int>)val).Min = 10;
				((BaseRangeOptions<int>)val).Max = 3840;
				((BaseOptions)val).RequiresRestart = false;
				((BaseOptions)val).CanModifyCallback = new CanModifyDelegate(CanModifySize);
				LethalConfigManager.AddConfigItem((BaseConfigItem)new IntSliderConfigItem(width, val));
				ConfigEntry<int> height = config._height;
				IntSliderOptions val2 = new IntSliderOptions();
				((BaseRangeOptions<int>)val2).Min = 10;
				((BaseRangeOptions<int>)val2).Max = 2160;
				((BaseOptions)val2).RequiresRestart = false;
				((BaseOptions)val2).CanModifyCallback = new CanModifyDelegate(CanModifySize);
				LethalConfigManager.AddConfigItem((BaseConfigItem)new IntSliderConfigItem(height, val2));
				object obj = <>c.<>9__0_0;
				if (obj == null)
				{
					GenericButtonHandler val3 = delegate
					{
						FCRResPatches.UpdateAll();
					};
					<>c.<>9__0_0 = val3;
					obj = (object)val3;
				}
				LethalConfigManager.AddConfigItem((BaseConfigItem)new GenericButtonConfigItem("Resolutions", "Refresh resolution", "If the resolution has been released for some reason, you can refresh it using this button.", "Refresh", (GenericButtonHandler)obj));
			}

			private static CanModifyResult CanModifyAutoSize()
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				return CanModifyResult.op_Implicit((FCRPlugin.resConfig?.enable ?? true, "Resolution patch is disabled and cannot be modified"));
			}

			private static CanModifyResult CanModifySize()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: 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)
				CanModifyResult val = CanModifyAutoSize();
				if (CanModifyResult.op_Implicit(val))
				{
					return CanModifyResult.op_Implicit((!(FCRPlugin.resConfig?.autoSize ?? true), "Since auto size is enabled, the size is automatically set to the current game window size."));
				}
				return val;
			}
		}

		private readonly ConfigEntry<bool> _enable;

		public const bool dEnable = true;

		private readonly ConfigEntry<bool> _autoSize;

		public const bool dAutoSize = true;

		private readonly ConfigEntry<int> _width;

		public const int dWidth = 1920;

		private readonly ConfigEntry<int> _height;

		public const int dHeight = 1080;

		public bool enable
		{
			get
			{
				return _enable.Value;
			}
			set
			{
				_enable.Value = value;
			}
		}

		public bool autoSize
		{
			get
			{
				return _autoSize.Value;
			}
			set
			{
				_autoSize.Value = value;
			}
		}

		public int width
		{
			get
			{
				return _width.Value;
			}
			set
			{
				_width.Value = value;
			}
		}

		public int height
		{
			get
			{
				return _height.Value;
			}
			set
			{
				_height.Value = value;
			}
		}

		internal static FCRResConfig? Create(ConfigFile config)
		{
			Debug.Log("Resolution Config Loading...");
			try
			{
				FCRResConfig result = new FCRResConfig(config);
				Debug.Log("Resolution Config Loaded!");
				return result;
			}
			catch (Exception data)
			{
				Debug.LogError(data);
				Debug.LogWarning("Failed to load config file\nSettings will be loaded with defaults!");
			}
			return null;
		}

		private FCRResConfig(ConfigFile config)
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Expected O, but got Unknown
			_enable = config.Bind<bool>("Resolutions", "Enable", true, "When enabled, the camera resolution will be modified.");
			_enable.SettingChanged += delegate
			{
				FCRPlugin.Repatch();
			};
			_autoSize = config.Bind<bool>("Resolutions", "Auto Size", true, "When enabled, sets the camera size to the size of the current game window.");
			_autoSize.SettingChanged += delegate
			{
				FCRResPatches.UpdateAll();
			};
			_width = config.Bind<int>("Resolutions", "Width", 1920, new ConfigDescription(string.Empty, (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 3840), Array.Empty<object>()));
			_width.SettingChanged += delegate
			{
				FCRResPatches.UpdateAll();
			};
			_height = config.Bind<int>("Resolutions", "Height", 1080, new ConfigDescription(string.Empty, (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 2160), Array.Empty<object>()));
			_height.SettingChanged += delegate
			{
				FCRResPatches.UpdateAll();
			};
		}
	}
	public static class FCRResPatches
	{
		public const int orgWidth = 860;

		public const int orgHeight = 520;

		public static bool enable => FCRPlugin.resConfig?.enable ?? true;

		public static int width
		{
			get
			{
				if (enable)
				{
					FCRResConfig? resConfig = FCRPlugin.resConfig;
					if (resConfig == null || resConfig.autoSize)
					{
						return Screen.width;
					}
					return FCRPlugin.resConfig?.width ?? 1920;
				}
				return 860;
			}
		}

		public static int height
		{
			get
			{
				if (enable)
				{
					FCRResConfig? resConfig = FCRPlugin.resConfig;
					if (resConfig == null || resConfig.autoSize)
					{
						return Screen.height;
					}
					return FCRPlugin.resConfig?.height ?? 1080;
				}
				return 520;
			}
		}

		[HarmonyPatch(typeof(Terminal), "Start")]
		[HarmonyPostfix]
		private static void Terminal_Start_Postfix(Terminal __instance)
		{
			UpdateRenderTexture(__instance.playerScreenTex);
			UpdateRenderTexture(__instance.playerScreenTexHighRes);
		}

		[HarmonyPatch(typeof(HUDManager), "UpdateScanNodes")]
		[HarmonyPostfix]
		private static void HUDManager_UpdateScanNodes_Postfix(HUDManager __instance)
		{
			//IL_0016: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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_005e: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			if (enable)
			{
				for (int i = 0; i < __instance.scanElements.Length; i++)
				{
					RectTransform obj = __instance.scanElements[i];
					obj.anchoredPosition += new Vector2(439.48f, 244.8f);
					obj.anchoredPosition = obj.anchoredPosition.Multiply(860f / (float)width, 520f / (float)height);
					obj.anchoredPosition -= new Vector2(439.48f, 244.8f);
				}
			}
		}

		public static void UpdateAll()
		{
			UpdateAllTerminal();
			UpdateAllPlayerCamera();
		}

		public static void UpdateAllTerminal()
		{
			Terminal[] array = Object.FindObjectsByType<Terminal>((FindObjectsSortMode)0);
			foreach (Terminal obj in array)
			{
				UpdateRenderTexture(obj.playerScreenTex);
				UpdateRenderTexture(obj.playerScreenTexHighRes);
			}
		}

		public static void UpdateRenderTexture(RenderTexture renderTexture)
		{
			renderTexture.Release();
			((Texture)renderTexture).width = width;
			((Texture)renderTexture).height = height;
			Debug.Log($"Changed the size of the render texture to {((Texture)renderTexture).width}x{((Texture)renderTexture).height}");
		}

		public static void UpdateAllPlayerCamera()
		{
			PlayerControllerB[] array = Object.FindObjectsByType<PlayerControllerB>((FindObjectsSortMode)0);
			for (int i = 0; i < array.Length; i++)
			{
				UpdateCamera(array[i].gameplayCamera);
			}
		}

		public static void UpdateCamera(Camera camera)
		{
			camera.ResetAspect();
		}

		internal static void Patch()
		{
			if (!enable)
			{
				return;
			}
			Debug.Log("Resolution Patch...");
			try
			{
				FCRPlugin.harmony.PatchAll(typeof(FCRResPatches));
				Debug.Log("Resolution Patched!");
			}
			catch (Exception data)
			{
				Debug.LogError(data);
				Debug.LogError("Resolution Patch Fail!");
			}
		}
	}
}
namespace Rumi.FixCameraResolutions.Fogs
{
	public enum AntialiasingMode
	{
		None,
		FXAA,
		TAA,
		SMAA
	}
	public sealed class FCRHDRPConfig
	{
		public static class LethalConfig
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			public static void Patch(FCRHDRPConfig config)
			{
				LethalConfigManager.AddConfigItem((BaseConfigItem)(object)new EnumDropDownConfigItem<AntialiasingMode>(config._antialiasingMode, false));
				LethalConfigManager.AddConfigItem((BaseConfigItem)(object)new EnumDropDownConfigItem<HDRPMode>(config._bloomMode, false));
				LethalConfigManager.AddConfigItem((BaseConfigItem)(object)new EnumDropDownConfigItem<FogMode>(config._fogMode, false));
				LethalConfigManager.AddConfigItem((BaseConfigItem)(object)new EnumDropDownConfigItem<HDRPMode>(config._shadowMode, false));
				LethalConfigManager.AddConfigItem((BaseConfigItem)(object)new EnumDropDownConfigItem<HDRPMode>(config._postProcessingMode, false));
				LethalConfigManager.AddConfigItem((BaseConfigItem)(object)new EnumDropDownConfigItem<HDRPMode>(config._vignetteMode, false));
			}
		}

		private readonly ConfigEntry<AntialiasingMode> _antialiasingMode;

		public const AntialiasingMode dAntialiasingMode = AntialiasingMode.None;

		private readonly ConfigEntry<HDRPMode> _bloomMode;

		public const HDRPMode dBloomMode = HDRPMode.Vanilla;

		private readonly ConfigEntry<FogMode> _fogMode;

		public const FogMode dFogMode = FogMode.Vanilla;

		private readonly ConfigEntry<HDRPMode> _shadowMode;

		public const HDRPMode dShadowMode = HDRPMode.Vanilla;

		private readonly ConfigEntry<HDRPMode> _postProcessingMode;

		public const HDRPMode dPostProcessingMode = HDRPMode.Vanilla;

		private readonly ConfigEntry<HDRPMode> _vignetteMode;

		public const HDRPMode dVignetteMode = HDRPMode.Vanilla;

		public AntialiasingMode antialiasingMode
		{
			get
			{
				return _antialiasingMode.Value;
			}
			set
			{
				_antialiasingMode.Value = value;
			}
		}

		public HDRPMode bloomMode
		{
			get
			{
				return _bloomMode.Value;
			}
			set
			{
				_bloomMode.Value = value;
			}
		}

		public FogMode fogMode
		{
			get
			{
				return _fogMode.Value;
			}
			set
			{
				_fogMode.Value = value;
			}
		}

		public HDRPMode shadowMode
		{
			get
			{
				return _shadowMode.Value;
			}
			set
			{
				_shadowMode.Value = value;
			}
		}

		public HDRPMode postProcessingMode
		{
			get
			{
				return _postProcessingMode.Value;
			}
			set
			{
				_postProcessingMode.Value = value;
			}
		}

		public HDRPMode vignetteMode
		{
			get
			{
				return _vignetteMode.Value;
			}
			set
			{
				_vignetteMode.Value = value;
			}
		}

		internal static FCRHDRPConfig? Create(ConfigFile config)
		{
			Debug.Log("HDRP Config Loading...");
			try
			{
				FCRHDRPConfig result = new FCRHDRPConfig(config);
				Debug.Log("HDRP Config Loaded!");
				return result;
			}
			catch (Exception data)
			{
				Debug.LogError(data);
				Debug.LogWarning("Failed to load config file\nSettings will be loaded with defaults!");
			}
			return null;
		}

		private FCRHDRPConfig(ConfigFile config)
		{
			_antialiasingMode = config.Bind<AntialiasingMode>("HDRP", "Antialiasing", AntialiasingMode.None, (ConfigDescription)null);
			_bloomMode = config.Bind<HDRPMode>("HDRP", "Bloom", HDRPMode.Vanilla, (ConfigDescription)null);
			_fogMode = config.Bind<FogMode>("HDRP", "Fog Rendering Method", FogMode.Vanilla, "Sets how fog is rendered.\r\n\r\n-------------------------\r\n\r\n\r\nVanilla\r\n-------------------------\r\nUse default fog settings\r\n\r\n\r\nHide\r\n-------------------------\r\nIt doesn't completely remove the fog, but it adjusts it so that it doesn't obstruct your vision.\r\n\r\n\r\nDisable\r\n-------------------------\r\nCompletely disables all fog rendering.\r\n\r\n\r\nForceDisable\r\n-------------------------\r\nAttempts to completely disable all fog rendering on every frame.\r\n\r\nCan be used when fog removal is not working on a mod planet\r\n\r\nDo not use this setting unless you have a problem\r\n\r\n\r\n-------------------------\r\n\r\n");
			_shadowMode = config.Bind<HDRPMode>("HDRP", "Shadow", HDRPMode.Vanilla, (ConfigDescription)null);
			_postProcessingMode = config.Bind<HDRPMode>("HDRP", "Post Processing", HDRPMode.Vanilla, (ConfigDescription)null);
			_vignetteMode = config.Bind<HDRPMode>("HDRP", "Vignette", HDRPMode.Vanilla, (ConfigDescription)null);
			_antialiasingMode.SettingChanged += delegate
			{
				FCRPlugin.Repatch();
			};
			_bloomMode.SettingChanged += delegate
			{
				FCRPlugin.Repatch();
			};
			_fogMode.SettingChanged += delegate
			{
				FCRPlugin.Repatch();
			};
			_shadowMode.SettingChanged += delegate
			{
				FCRPlugin.Repatch();
			};
			_postProcessingMode.SettingChanged += delegate
			{
				FCRPlugin.Repatch();
			};
			_vignetteMode.SettingChanged += delegate
			{
				FCRPlugin.Repatch();
			};
		}
	}
	public static class FCRHDRPPatches
	{
		[HarmonyPatch(typeof(Volume))]
		private static class OnEnablePatch
		{
			[HarmonyPatch("OnEnable")]
			[HarmonyPostfix]
			private static void OnEnable(Volume __instance)
			{
				UpdateVolume(__instance);
			}
		}

		[HarmonyPatch(typeof(Volume))]
		private static class UpdatePatch
		{
			[HarmonyPatch("Update")]
			[HarmonyPostfix]
			private static void Update(Volume __instance)
			{
				UpdateVolume(__instance);
			}
		}

		[HarmonyPatch(typeof(HDAdditionalCameraData))]
		private static class HDAdditionalCameraDataPatch
		{
			[HarmonyPatch("Awake")]
			[HarmonyPostfix]
			private static void Awake(HDAdditionalCameraData __instance)
			{
				UpdateHDCameraData(__instance);
			}
		}

		public static AntialiasingMode antialiasingMode => FCRPlugin.hdrpConfig?.antialiasingMode ?? AntialiasingMode.None;

		public static HDRPMode bloomMode => FCRPlugin.hdrpConfig?.bloomMode ?? HDRPMode.Vanilla;

		public static FogMode fogMode => FCRPlugin.hdrpConfig?.fogMode ?? FogMode.Vanilla;

		public static HDRPMode shadowMode => FCRPlugin.hdrpConfig?.shadowMode ?? HDRPMode.Vanilla;

		public static HDRPMode postProcessingMode => FCRPlugin.hdrpConfig?.postProcessingMode ?? HDRPMode.Vanilla;

		public static HDRPMode vignetteMode => FCRPlugin.hdrpConfig?.vignetteMode ?? HDRPMode.Vanilla;

		public static void UpdateAll()
		{
			UpdateAllVolume();
			UpdateAllHDCameraData();
		}

		public static void UpdateAllVolume()
		{
			Volume[] array = Object.FindObjectsByType<Volume>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			for (int i = 0; i < array.Length; i++)
			{
				UpdateVolume(array[i]);
			}
		}

		public static void UpdateVolume(Volume volume)
		{
			Fog val = default(Fog);
			if (!((Object)(object)volume.sharedProfile == (Object)null) && volume.sharedProfile.TryGet<Fog>(ref val))
			{
				((VolumeComponent)val).active = fogMode != FogMode.Disable && fogMode != FogMode.ForceDisable;
			}
		}

		public static void UpdateAllHDCameraData()
		{
			HDAdditionalCameraData[] array = Object.FindObjectsByType<HDAdditionalCameraData>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			for (int i = 0; i < array.Length; i++)
			{
				UpdateHDCameraData(array[i]);
			}
		}

		public static void UpdateHDCameraData(HDAdditionalCameraData cameraData)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (((Object)((Component)cameraData).gameObject).name == "SpectateCamera")
			{
				cameraData.customRenderingSettings = fogMode != FogMode.Vanilla;
			}
			if (((Object)((Component)cameraData).gameObject).name != "UICamera")
			{
				cameraData.antialiasing = (AntialiasingMode)antialiasingMode;
				((BitArray128)(ref cameraData.renderingPathCustomFrameSettingsOverrideMask.mask))[91u] = antialiasingMode != AntialiasingMode.None;
				((FrameSettings)(ref cameraData.renderingPathCustomFrameSettings)).SetEnabled((FrameSettingsField)91, antialiasingMode != AntialiasingMode.None);
			}
			((BitArray128)(ref cameraData.renderingPathCustomFrameSettingsOverrideMask.mask))[84u] = bloomMode != HDRPMode.Vanilla;
			((FrameSettings)(ref cameraData.renderingPathCustomFrameSettings)).SetEnabled((FrameSettingsField)84, bloomMode == HDRPMode.Vanilla);
			((BitArray128)(ref cameraData.renderingPathCustomFrameSettingsOverrideMask.mask))[28u] = fogMode != FogMode.Vanilla;
			((FrameSettings)(ref cameraData.renderingPathCustomFrameSettings)).SetEnabled((FrameSettingsField)28, fogMode == FogMode.Vanilla);
			((BitArray128)(ref cameraData.renderingPathCustomFrameSettingsOverrideMask.mask))[20u] = shadowMode != HDRPMode.Vanilla;
			((FrameSettings)(ref cameraData.renderingPathCustomFrameSettings)).SetEnabled((FrameSettingsField)20, shadowMode == HDRPMode.Vanilla);
			((BitArray128)(ref cameraData.renderingPathCustomFrameSettingsOverrideMask.mask))[6u] = postProcessingMode != HDRPMode.Vanilla;
			((FrameSettings)(ref cameraData.renderingPathCustomFrameSettings)).SetEnabled((FrameSettingsField)6, postProcessingMode == HDRPMode.Vanilla);
			((BitArray128)(ref cameraData.renderingPathCustomFrameSettingsOverrideMask.mask))[87u] = vignetteMode != HDRPMode.Vanilla;
			((FrameSettings)(ref cameraData.renderingPathCustomFrameSettings)).SetEnabled((FrameSettingsField)87, vignetteMode == HDRPMode.Vanilla);
		}

		internal static void Patch()
		{
			Debug.Log("Fog Patch...");
			try
			{
				FCRPlugin.harmony.PatchAll(typeof(HDAdditionalCameraDataPatch));
				if (fogMode == FogMode.Disable || fogMode == FogMode.ForceDisable)
				{
					FCRPlugin.harmony.PatchAll(typeof(OnEnablePatch));
					if (fogMode == FogMode.ForceDisable)
					{
						FCRPlugin.harmony.PatchAll(typeof(UpdatePatch));
					}
				}
				Debug.Log("Fog Patched!");
			}
			catch (Exception data)
			{
				Debug.LogError(data);
				Debug.LogError("Fog Patch Fail!");
			}
		}
	}
	public enum FogMode
	{
		Vanilla,
		Hide,
		Disable,
		ForceDisable
	}
	public enum HDRPMode
	{
		Vanilla,
		Disable
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}