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.Rendering.PostProcessing;
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: AssemblyCompany("Omniscye")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("TrueRealism")]
[assembly: AssemblyTitle("TrueRealism")]
[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.RealismOverhaul
{
	[BepInPlugin("Empress.RealismOverhaul", "RealismOverhaul", "1.1.0")]
	public class RealismOverhaul : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <DeferredGMRefresh>d__63 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RealismOverhaul <>4__this;

			private float <t>5__1;

			private GraphicsManager <gmi>5__2;

			private GraphicsManager <gm>5__3;

			private PostProcessing <pp>5__4;

			private Exception <e>5__5;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DeferredGMRefresh>d__63(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<gmi>5__2 = null;
				<gm>5__3 = null;
				<pp>5__4 = null;
				<e>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<t>5__1 = 0f;
					break;
				case 1:
					<>1__state = -1;
					<gm>5__3 = null;
					<pp>5__4 = null;
					break;
				}
				if (<t>5__1 < 5f)
				{
					<gm>5__3 = GraphicsManager.instance;
					<pp>5__4 = PostProcessing.Instance;
					if (!((Object)(object)<gm>5__3 != (Object)null) || !((Object)(object)<pp>5__4 != (Object)null) || !((Object)(object)<pp>5__4.volume != (Object)null))
					{
						<t>5__1 += Time.unscaledDeltaTime;
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
				}
				<gmi>5__2 = GraphicsManager.instance;
				if ((Object)(object)<gmi>5__2 != (Object)null)
				{
					try
					{
						<gmi>5__2.UpdateAll();
					}
					catch (Exception ex)
					{
						<e>5__5 = ex;
						Logger.LogWarning((object)("Deferred UpdateAll failed: " + <e>5__5.Message));
					}
				}
				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();
			}
		}

		public const string PluginGuid = "Empress.RealismOverhaul";

		public const string PluginName = "RealismOverhaul";

		public const string PluginVersion = "1.1.0";

		private static PostProcessResources? _ppResourcesCache;

		private static bool _missingResourcesLogged;

		private ConfigEntry<bool> _enableOverhaul = null;

		private ConfigEntry<bool> _respectGameSliders = null;

		private ConfigEntry<bool> _disableStylizedFX = null;

		private ConfigEntry<bool> _disablePostProcessingOverlay = null;

		private ConfigEntry<bool> _enableAmbientOcclusion = null;

		private ConfigEntry<bool> _enableBloom = null;

		private ConfigEntry<bool> _enableDepthOfField = null;

		private ConfigEntry<string> _antialiasingMode = null;

		private ConfigEntry<float> _aoIntensity = null;

		private ConfigEntry<float> _aoRadius = null;

		private ConfigEntry<float> _bloomIntensity = null;

		private ConfigEntry<float> _bloomThreshold = null;

		private ConfigEntry<float> _dofFocusDistance = null;

		private ConfigEntry<float> _dofAperture = null;

		private ConfigEntry<float> _dofFocalLength = null;

		private ConfigEntry<float> _postExposure = null;

		private ConfigEntry<int> _shadowCascades = null;

		private ConfigEntry<float> _shadowDistance = null;

		private ConfigEntry<string> _shadowResolution = null;

		private ConfigEntry<float> _lodBias = null;

		private ConfigEntry<bool> _motionBlur = null;

		private ConfigEntry<float> _motionBlurShutter = null;

		private float _dynTimer;

		private float _dynScale = 1f;

		private float _largeW;

		private float _largeH;

		private bool _noPixActive;

		private readonly Queue<float> _frameTimes = new Queue<float>(120);

		private bool _overlayHandledThisScene;

		private const string OverlayName = "Post Processing Overlay";

		internal static RealismOverhaul 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;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			BindConfig();
			Patch();
			SceneManager.sceneLoaded += delegate
			{
				_overlayHandledThisScene = false;
				SafeApplyAll("sceneLoaded");
				ApplyForcedGameSettings();
				TryDisablePostProcessingOverlay();
				((MonoBehaviour)this).StartCoroutine(DeferredGMRefresh());
			};
			((MonoBehaviour)this).InvokeRepeating("EnsureCamerasHavePPLayer", 1f, 3f);
			((MonoBehaviour)this).InvokeRepeating("TryDisablePostProcessingOverlay", 0.25f, 2f);
			Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} engaged.");
		}

		private void BindConfig()
		{
			_enableOverhaul = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableOverhaul", true, "");
			_respectGameSliders = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "RespectGameSliders", false, "");
			_disableStylizedFX = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "DisableStylizedFX", true, "");
			_disablePostProcessingOverlay = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "DisablePostProcessingOverlay", true, "If true, finds the GameObject named \"Post Processing Overlay\" and disables it. Exact mimic of the other mod.");
			_antialiasingMode = ((BaseUnityPlugin)this).Config.Bind<string>("PostFX", "Antialiasing", "TAA", "");
			_enableAmbientOcclusion = ((BaseUnityPlugin)this).Config.Bind<bool>("PostFX", "AmbientOcclusion", true, "");
			_aoIntensity = ((BaseUnityPlugin)this).Config.Bind<float>("PostFX", "AOIntensity", 0.9f, "");
			_aoRadius = ((BaseUnityPlugin)this).Config.Bind<float>("PostFX", "AORadius", 0.35f, "");
			_enableBloom = ((BaseUnityPlugin)this).Config.Bind<bool>("PostFX", "Bloom", false, "");
			_bloomIntensity = ((BaseUnityPlugin)this).Config.Bind<float>("PostFX", "BloomIntensity", 3.5f, "");
			_bloomThreshold = ((BaseUnityPlugin)this).Config.Bind<float>("PostFX", "BloomThreshold", 1.08f, "");
			_enableDepthOfField = ((BaseUnityPlugin)this).Config.Bind<bool>("PostFX", "DepthOfField", true, "");
			_dofFocusDistance = ((BaseUnityPlugin)this).Config.Bind<float>("PostFX", "DOFFocusDistance", 3.5f, "");
			_dofAperture = ((BaseUnityPlugin)this).Config.Bind<float>("PostFX", "DOFAperture", 4f, "");
			_dofFocalLength = ((BaseUnityPlugin)this).Config.Bind<float>("PostFX", "DOFFocalLength", 50f, "");
			_postExposure = ((BaseUnityPlugin)this).Config.Bind<float>("PostFX", "PostExposureEV", 0f, "");
			_motionBlur = ((BaseUnityPlugin)this).Config.Bind<bool>("PostFX", "MotionBlur", false, "");
			_motionBlurShutter = ((BaseUnityPlugin)this).Config.Bind<float>("PostFX", "MotionBlurShutter", -3.576279E-08f, "");
			_shadowCascades = ((BaseUnityPlugin)this).Config.Bind<int>("Quality", "ShadowCascades", 4, "");
			_shadowDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Quality", "ShadowDistance", 180f, "");
			_shadowResolution = ((BaseUnityPlugin)this).Config.Bind<string>("Quality", "ShadowResolution", "VeryHigh", "");
			_lodBias = ((BaseUnityPlugin)this).Config.Bind<float>("Quality", "LODBias", 2f, "");
		}

		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(typeof(RealismOverhaul));
		}

		internal void Unpatch()
		{
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private void Start()
		{
			SafeApplyAll("start");
			ApplyForcedGameSettings();
			TryDisablePostProcessingOverlay();
			((MonoBehaviour)this).StartCoroutine(DeferredGMRefresh());
		}

		private void Update()
		{
			if (!_enableOverhaul.Value)
			{
				return;
			}
			_frameTimes.Enqueue(Time.deltaTime);
			if (_frameTimes.Count > 120)
			{
				_frameTimes.Dequeue();
			}
			_dynTimer += Time.unscaledDeltaTime;
			if (!(_dynTimer >= 0.5f))
			{
				return;
			}
			_dynTimer = 0f;
			if (!_noPixActive || !((Object)(object)RenderTextureMain.instance != (Object)null) || !(_largeW > 0f) || !(_largeH > 0f))
			{
				return;
			}
			float num = 0f;
			foreach (float frameTime in _frameTimes)
			{
				num += frameTime;
			}
			num /= (float)Mathf.Max(1, _frameTimes.Count);
			float num2 = ((num > 0f) ? (1f / num) : 300f);
			int num3 = ((Application.targetFrameRate > 0) ? Application.targetFrameRate : 60);
			if (num2 < (float)(num3 - 2))
			{
				_dynScale = Mathf.Max(0.8f, _dynScale - 0.05f);
			}
			else if (num2 > (float)(num3 + 5))
			{
				_dynScale = Mathf.Min(1f, _dynScale + 0.05f);
			}
			float num4 = Mathf.Round(_largeW * _dynScale);
			float num5 = Mathf.Round(_largeH * _dynScale);
			RenderTextureMain.instance.ChangeResolution(num4, num5, 0.6f);
		}

		private void TryDisablePostProcessingOverlay()
		{
			if (!_disablePostProcessingOverlay.Value || _overlayHandledThisScene)
			{
				return;
			}
			GameObject val = GameObject.Find("Post Processing Overlay");
			if ((Object)(object)val != (Object)null)
			{
				if (val.activeSelf)
				{
					val.SetActive(false);
					Logger.LogInfo((object)"Disabled \"Post Processing Overlay\" GameObject.");
				}
				_overlayHandledThisScene = true;
			}
		}

		private static void SafeApplyAll(string reason)
		{
			if (!Instance._enableOverhaul.Value)
			{
				return;
			}
			try
			{
				ApplyQualitySettings();
				Instance.EnsureCamerasHavePPLayer();
				ApplyPostProcessingProfile();
				Instance.EnsureNoPixelationAndCaptureBaseSize();
			}
			catch (Exception ex)
			{
				Logger.LogWarning((object)$"Apply failed ({reason}): {ex.Message}\n{ex}");
			}
		}

		private static PostProcessResources? ResolvePPResources()
		{
			if ((Object)(object)_ppResourcesCache != (Object)null)
			{
				return _ppResourcesCache;
			}
			try
			{
				_ppResourcesCache = Resources.Load<PostProcessResources>("PostProcessResources");
				if ((Object)(object)_ppResourcesCache == (Object)null)
				{
					PostProcessLayer val = ((IEnumerable<PostProcessLayer>)Resources.FindObjectsOfTypeAll<PostProcessLayer>()).FirstOrDefault((Func<PostProcessLayer, bool>)((PostProcessLayer l) => (Object)(object)l != (Object)null));
					if ((Object)(object)val != (Object)null)
					{
						FieldInfo fieldInfo = typeof(PostProcessLayer).GetField("m_Resources", BindingFlags.Instance | BindingFlags.NonPublic) ?? typeof(PostProcessLayer).GetField("resources", BindingFlags.Instance | BindingFlags.Public);
						if (fieldInfo != null)
						{
							object? value = fieldInfo.GetValue(val);
							_ppResourcesCache = (PostProcessResources?)((value is PostProcessResources) ? value : null);
						}
					}
				}
			}
			catch
			{
			}
			if ((Object)(object)_ppResourcesCache == (Object)null && !_missingResourcesLogged)
			{
				_missingResourcesLogged = true;
				Logger.LogWarning((object)"PostProcessResources not found.");
			}
			return _ppResourcesCache;
		}

		private static bool LayerHasResources(PostProcessLayer layer)
		{
			try
			{
				FieldInfo fieldInfo = typeof(PostProcessLayer).GetField("m_Resources", BindingFlags.Instance | BindingFlags.NonPublic) ?? typeof(PostProcessLayer).GetField("resources", BindingFlags.Instance | BindingFlags.Public);
				if (fieldInfo == null)
				{
					return false;
				}
				object? value = fieldInfo.GetValue(layer);
				return (Object)((value is PostProcessResources) ? value : null) != (Object)null;
			}
			catch
			{
				return false;
			}
		}

		private static void EnsureLayerHasResources(PostProcessLayer layer, PostProcessResources? res)
		{
			if ((Object)(object)res == (Object)null)
			{
				return;
			}
			try
			{
				FieldInfo fieldInfo = typeof(PostProcessLayer).GetField("m_Resources", BindingFlags.Instance | BindingFlags.NonPublic) ?? typeof(PostProcessLayer).GetField("resources", BindingFlags.Instance | BindingFlags.Public);
				if (fieldInfo != null)
				{
					fieldInfo.SetValue(layer, res);
				}
			}
			catch
			{
			}
		}

		private void EnsureCamerasHavePPLayer()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Invalid comparison between Unknown and I4
			//IL_00d1: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			PostProcessResources res = ResolvePPResources();
			Camera[] array = Resources.FindObjectsOfTypeAll<Camera>();
			foreach (Camera val in array)
			{
				if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeInHierarchy || (int)val.cameraType != 1)
				{
					continue;
				}
				PostProcessLayer val2 = ((Component)val).GetComponent<PostProcessLayer>();
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = ((Component)val).gameObject.AddComponent<PostProcessLayer>();
					val2.volumeTrigger = ((Component)val).transform;
					EnsureLayerHasResources(val2, res);
				}
				else
				{
					if ((Object)(object)val2.volumeTrigger == (Object)null)
					{
						val2.volumeTrigger = ((Component)val).transform;
					}
					if (!LayerHasResources(val2))
					{
						EnsureLayerHasResources(val2, res);
					}
				}
				val2.volumeLayer = LayerMask.op_Implicit(-1);
				string text = _antialiasingMode.Value.ToUpperInvariant();
				string text2 = text;
				if (!(text2 == "TAA"))
				{
					if (text2 == "FXAA")
					{
						val2.antialiasingMode = (Antialiasing)1;
						QualitySettings.antiAliasing = 0;
						val.allowMSAA = false;
					}
					else
					{
						val2.antialiasingMode = (Antialiasing)0;
					}
					continue;
				}
				val2.antialiasingMode = (Antialiasing)3;
				TemporalAntialiasing temporalAntialiasing = val2.temporalAntialiasing;
				if (temporalAntialiasing != null)
				{
					temporalAntialiasing.jitterSpread = 0.65f;
					temporalAntialiasing.motionBlending = 0.7f;
					temporalAntialiasing.stationaryBlending = 0.95f;
				}
				QualitySettings.antiAliasing = 0;
				val.allowMSAA = false;
			}
		}

		private static void ApplyQualitySettings()
		{
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Invalid comparison between Unknown and I4
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Invalid comparison between Unknown and I4
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Invalid comparison between Unknown and I4
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Invalid comparison between Unknown and I4
			QualitySettings.anisotropicFiltering = (AnisotropicFiltering)2;
			QualitySettings.realtimeReflectionProbes = true;
			QualitySettings.billboardsFaceCameraPosition = true;
			QualitySettings.lodBias = Mathf.Max(1f, Instance._lodBias.Value);
			QualitySettings.shadowDistance = Mathf.Max(20f, Instance._shadowDistance.Value);
			QualitySettings.shadowCascades = Mathf.Clamp(Instance._shadowCascades.Value, 0, 4);
			QualitySettings.softParticles = true;
			switch (Instance._shadowResolution.Value.ToLowerInvariant())
			{
			case "veryhigh":
				QualitySettings.shadowResolution = (ShadowResolution)3;
				break;
			case "high":
				QualitySettings.shadowResolution = (ShadowResolution)2;
				break;
			case "medium":
				QualitySettings.shadowResolution = (ShadowResolution)1;
				break;
			default:
				QualitySettings.shadowResolution = (ShadowResolution)0;
				break;
			}
			Light[] array = Resources.FindObjectsOfTypeAll<Light>();
			foreach (Light val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					if ((int)val.type == 1)
					{
						val.shadows = (LightShadows)2;
					}
					else if (((int)val.type == 2 || (int)val.type == 0) && (int)val.shadows == 0)
					{
						val.shadows = (LightShadows)2;
					}
				}
			}
		}

		private static void ApplyPostProcessingProfile()
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			PostProcessing instance = PostProcessing.Instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.volume == (Object)null)
			{
				return;
			}
			PostProcessVolume volume = instance.volume;
			PostProcessProfile val = volume.profile ?? ScriptableObject.CreateInstance<PostProcessProfile>();
			if ((Object)(object)volume.profile == (Object)null)
			{
				volume.profile = val;
			}
			PostProcessResources val2 = ResolvePPResources();
			AmbientOcclusion val3 = default(AmbientOcclusion);
			if ((Object)(object)val2 == (Object)null && val.TryGetSettings<AmbientOcclusion>(ref val3))
			{
				((ParameterOverride<bool>)(object)((PostProcessEffectSettings)val3).enabled).value = false;
			}
			ColorGrading val4 = default(ColorGrading);
			if (!val.TryGetSettings<ColorGrading>(ref val4))
			{
				val4 = val.AddSettings<ColorGrading>();
			}
			((ParameterOverride<Tonemapper>)(object)val4.tonemapper).value = (Tonemapper)2;
			((ParameterOverride<float>)(object)val4.postExposure).value = Instance._postExposure.Value;
			((ParameterOverride<float>)(object)val4.saturation).value = 0f;
			((ParameterOverride<float>)(object)val4.contrast).value = 10f;
			((ParameterOverride<Vector4>)(object)val4.gamma).value = new Vector4(0f, 0f, 0f, 0f);
			((ParameterOverride<bool>)(object)((PostProcessEffectSettings)val4).enabled).value = true;
			AmbientOcclusion val6 = default(AmbientOcclusion);
			if (Instance._enableAmbientOcclusion.Value)
			{
				AmbientOcclusion val5 = default(AmbientOcclusion);
				if (!val.TryGetSettings<AmbientOcclusion>(ref val5))
				{
					val5 = val.AddSettings<AmbientOcclusion>();
				}
				((ParameterOverride<bool>)(object)((PostProcessEffectSettings)val5).enabled).value = true;
				((ParameterOverride<AmbientOcclusionMode>)(object)val5.mode).value = (AmbientOcclusionMode)0;
				((ParameterOverride<AmbientOcclusionQuality>)(object)val5.quality).value = (AmbientOcclusionQuality)3;
				((ParameterOverride<float>)(object)val5.thicknessModifier).value = 1f;
				((ParameterOverride<float>)(object)val5.intensity).value = Mathf.Clamp(Instance._aoIntensity.Value, 0f, 4f);
				((ParameterOverride<float>)(object)val5.radius).value = Mathf.Clamp(Instance._aoRadius.Value, 0.05f, 1f);
			}
			else if (val.TryGetSettings<AmbientOcclusion>(ref val6))
			{
				((ParameterOverride<bool>)(object)((PostProcessEffectSettings)val6).enabled).value = false;
			}
			Bloom val8 = default(Bloom);
			if (Instance._enableBloom.Value)
			{
				Bloom val7 = default(Bloom);
				if (!val.TryGetSettings<Bloom>(ref val7))
				{
					val7 = val.AddSettings<Bloom>();
				}
				((ParameterOverride<bool>)(object)((PostProcessEffectSettings)val7).enabled).value = true;
				((ParameterOverride<float>)(object)val7.intensity).value = Mathf.Clamp(Instance._bloomIntensity.Value, 0f, 20f);
				((ParameterOverride<float>)(object)val7.threshold).value = Mathf.Clamp(Instance._bloomThreshold.Value, 0f, 10f);
				((ParameterOverride<bool>)(object)val7.fastMode).value = true;
			}
			else if (val.TryGetSettings<Bloom>(ref val8))
			{
				((ParameterOverride<bool>)(object)((PostProcessEffectSettings)val8).enabled).value = false;
			}
			DepthOfField val10 = default(DepthOfField);
			if (Instance._enableDepthOfField.Value)
			{
				DepthOfField val9 = default(DepthOfField);
				if (!val.TryGetSettings<DepthOfField>(ref val9))
				{
					val9 = val.AddSettings<DepthOfField>();
				}
				((ParameterOverride<bool>)(object)((PostProcessEffectSettings)val9).enabled).value = true;
				((ParameterOverride<float>)(object)val9.focusDistance).value = Mathf.Max(0.1f, Instance._dofFocusDistance.Value);
				((ParameterOverride<float>)(object)val9.aperture).value = Mathf.Clamp(Instance._dofAperture.Value, 0.7f, 32f);
				((ParameterOverride<float>)(object)val9.focalLength).value = Mathf.Clamp(Instance._dofFocalLength.Value, 1f, 300f);
				((ParameterOverride<KernelSize>)(object)val9.kernelSize).value = (KernelSize)1;
			}
			else if (val.TryGetSettings<DepthOfField>(ref val10))
			{
				((ParameterOverride<bool>)(object)((PostProcessEffectSettings)val10).enabled).value = false;
			}
			MotionBlur val11 = default(MotionBlur);
			if (val.TryGetSettings<MotionBlur>(ref val11))
			{
				((ParameterOverride<bool>)(object)((PostProcessEffectSettings)val11).enabled).value = false;
				((ParameterOverride<float>)(object)val11.shutterAngle).value = 0f;
				((ParameterOverride<int>)(object)val11.sampleCount).value = 0;
			}
			if (Instance._disableStylizedFX.Value)
			{
				ChromaticAberration val12 = default(ChromaticAberration);
				if (val.TryGetSettings<ChromaticAberration>(ref val12))
				{
					((ParameterOverride<bool>)(object)((PostProcessEffectSettings)val12).enabled).value = false;
					((ParameterOverride<float>)(object)val12.intensity).value = 0f;
				}
				LensDistortion val13 = default(LensDistortion);
				if (val.TryGetSettings<LensDistortion>(ref val13))
				{
					((ParameterOverride<bool>)(object)((PostProcessEffectSettings)val13).enabled).value = false;
					((ParameterOverride<float>)(object)val13.intensity).value = 0f;
				}
				Vignette val14 = default(Vignette);
				if (val.TryGetSettings<Vignette>(ref val14))
				{
					((ParameterOverride<bool>)(object)((PostProcessEffectSettings)val14).enabled).value = false;
					((ParameterOverride<float>)(object)val14.intensity).value = 0f;
				}
				Grain val15 = default(Grain);
				if (val.TryGetSettings<Grain>(ref val15))
				{
					((ParameterOverride<bool>)(object)((PostProcessEffectSettings)val15).enabled).value = false;
					((ParameterOverride<float>)(object)val15.intensity).value = 0f;
					((ParameterOverride<float>)(object)val15.size).value = 1f;
				}
			}
		}

		private void EnsureNoPixelationAndCaptureBaseSize()
		{
			RenderTextureMain instance = RenderTextureMain.instance;
			if (!((Object)(object)instance == (Object)null))
			{
				instance.textureWidthOriginal = instance.textureWidthLarge;
				instance.textureHeightOriginal = instance.textureHeightLarge;
				instance.ResetResolution();
				_largeW = instance.textureWidthLarge;
				_largeH = instance.textureHeightLarge;
				_noPixActive = true;
			}
		}

		private static void ApplyForcedGameSettings()
		{
			DataDirector instance = DataDirector.instance;
			if (!((Object)(object)instance == (Object)null))
			{
				instance.SettingValueSet((Setting)24, 0);
				instance.SettingValueSet((Setting)12, 0);
				instance.SettingValueSet((Setting)29, 41);
				instance.SettingValueSet((Setting)19, 90);
				instance.SettingValueSet((Setting)15, 4);
				instance.SettingValueSet((Setting)20, 3);
				instance.SettingValueSet((Setting)21, 4);
				instance.SettingValueSet((Setting)18, 0);
				instance.SettingValueSet((Setting)17, 0);
				instance.SettingValueSet((Setting)16, 0);
				instance.SettingValueSet((Setting)22, 0);
				instance.SettingValueSet((Setting)23, 0);
				instance.SettingValueSet((Setting)26, 0);
				instance.SettingValueSet((Setting)25, 2);
				instance.SaveSettings();
			}
		}

		[IteratorStateMachine(typeof(<DeferredGMRefresh>d__63))]
		private IEnumerator DeferredGMRefresh()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DeferredGMRefresh>d__63(0)
			{
				<>4__this = this
			};
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GraphicsManager), "UpdateAll")]
		private static void GM_UpdateAll_Postfix()
		{
			SafeApplyAll("GraphicsManager.UpdateAll");
			Instance?.TryDisablePostProcessingOverlay();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(GraphicsManager), "UpdateMotionBlur")]
		private static bool GM_UpdateMotionBlur_Prefix()
		{
			PostProcessing instance = PostProcessing.Instance;
			if ((Object)(object)instance != (Object)null && (Object)(object)instance.motionBlur != (Object)null)
			{
				((PostProcessEffectSettings)instance.motionBlur).active = false;
			}
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GraphicsManager), "UpdateBloom")]
		private static void GM_UpdateBloom_Postfix()
		{
			if (Instance._enableOverhaul.Value && !Instance._respectGameSliders.Value)
			{
				PostProcessing instance = PostProcessing.Instance;
				Bloom val = default(Bloom);
				if (!((Object)(object)instance == (Object)null) && !((Object)(object)instance.volume == (Object)null) && instance.volume.profile.TryGetSettings<Bloom>(ref val))
				{
					((ParameterOverride<bool>)(object)((PostProcessEffectSettings)val).enabled).value = Instance._enableBloom.Value;
					((ParameterOverride<float>)(object)val.intensity).value = Mathf.Clamp(Instance._bloomIntensity.Value, 0f, 20f);
					((ParameterOverride<float>)(object)val.threshold).value = Mathf.Clamp(Instance._bloomThreshold.Value, 0f, 10f);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GraphicsManager), "UpdateGrain")]
		private static void GM_UpdateGrain_Postfix()
		{
			if (Instance._enableOverhaul.Value && !Instance._respectGameSliders.Value)
			{
				PostProcessing instance = PostProcessing.Instance;
				Grain val = default(Grain);
				if (!((Object)(object)instance == (Object)null) && !((Object)(object)instance.volume == (Object)null) && instance.volume.profile.TryGetSettings<Grain>(ref val) && Instance._disableStylizedFX.Value)
				{
					((ParameterOverride<bool>)(object)((PostProcessEffectSettings)val).enabled).value = false;
					((ParameterOverride<float>)(object)val.intensity).value = 0f;
					((ParameterOverride<float>)(object)val.size).value = 1f;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GraphicsManager), "UpdateChromaticAberration")]
		private static void GM_UpdateCA_Postfix()
		{
			if (Instance._enableOverhaul.Value && !Instance._respectGameSliders.Value)
			{
				PostProcessing instance = PostProcessing.Instance;
				ChromaticAberration val = default(ChromaticAberration);
				if (!((Object)(object)instance == (Object)null) && !((Object)(object)instance.volume == (Object)null) && instance.volume.profile.TryGetSettings<ChromaticAberration>(ref val) && Instance._disableStylizedFX.Value)
				{
					((ParameterOverride<bool>)(object)((PostProcessEffectSettings)val).enabled).value = false;
					((ParameterOverride<float>)(object)val.intensity).value = 0f;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GraphicsManager), "UpdateLensDistortion")]
		private static void GM_UpdateLensDist_Postfix()
		{
			if (Instance._enableOverhaul.Value && !Instance._respectGameSliders.Value)
			{
				PostProcessing instance = PostProcessing.Instance;
				LensDistortion val = default(LensDistortion);
				if (!((Object)(object)instance == (Object)null) && !((Object)(object)instance.volume == (Object)null) && instance.volume.profile.TryGetSettings<LensDistortion>(ref val) && Instance._disableStylizedFX.Value)
				{
					((ParameterOverride<bool>)(object)((PostProcessEffectSettings)val).enabled).value = false;
					((ParameterOverride<float>)(object)val.intensity).value = 0f;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GraphicsManager), "UpdateShadowDistance")]
		private static void GM_UpdateShadowDistance_Postfix()
		{
			if (Instance._enableOverhaul.Value && !Instance._respectGameSliders.Value)
			{
				QualitySettings.shadowDistance = Mathf.Max(20f, Instance._shadowDistance.Value);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GraphicsManager), "UpdateShadowQuality")]
		private static void GM_UpdateShadowQuality_Postfix()
		{
			if (Instance._enableOverhaul.Value && !Instance._respectGameSliders.Value)
			{
				switch (Instance._shadowResolution.Value.ToLowerInvariant())
				{
				case "veryhigh":
					QualitySettings.shadowResolution = (ShadowResolution)3;
					break;
				case "high":
					QualitySettings.shadowResolution = (ShadowResolution)2;
					break;
				case "medium":
					QualitySettings.shadowResolution = (ShadowResolution)1;
					break;
				default:
					QualitySettings.shadowResolution = (ShadowResolution)0;
					break;
				}
				QualitySettings.shadowCascades = Mathf.Clamp(Instance._shadowCascades.Value, 0, 4);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GraphicsManager), "UpdateRenderSize")]
		private static void GM_UpdateRenderSize_Postfix()
		{
			if (Instance._enableOverhaul.Value)
			{
				Instance.EnsureNoPixelationAndCaptureBaseSize();
			}
		}
	}
}