using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HDPeak.Patches;
using HDPeak.Settings;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using SettingsExtender;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.Localization;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
using Zorro.Settings;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: AssemblyCompany("Nozz")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © 2025 Nozz")]
[assembly: AssemblyFileVersion("1.2.2")]
[assembly: AssemblyInformationalVersion("1.0.0+4e05afc280d9e740b2e52236c88d6585143973ad")]
[assembly: AssemblyProduct("HDPeak")]
[assembly: AssemblyTitle("HDPeak - Advanced Graphics Settings")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace HDPeak
{
	internal static class HDPeakPluginInfo
	{
		internal const string PLUGIN_GUID = "com.nozz.hdpeak";

		internal const string PLUGIN_NAME = "HDPeak";

		internal const string PLUGIN_VERSION = "1.2.2";
	}
	[BepInPlugin("com.nozz.hdpeak", "HDPeak", "1.2.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class HDPeakPlugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		internal static Harmony harmony;

		private GameObject buttonSrc;

		private bool settingsAdded;

		private void Awake()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"Plugin com.nozz.hdpeak is loaded!");
			SettingsRegistry.Register("HDPeak");
			harmony = new Harmony("com.nozz.hdpeak");
			harmony.PatchAll();
		}

		private void Start()
		{
			if (!settingsAdded)
			{
				try
				{
					Logger.LogInfo((object)"Adding Anti-Aliasing setting...");
					SettingsHandler.Instance.AddSetting((Setting)(object)new AntiAliasingSetting());
					Logger.LogInfo((object)"Adding Anisotropic Filtering setting...");
					SettingsHandler.Instance.AddSetting((Setting)(object)new AnisotropicFilteringSetting());
					Logger.LogInfo((object)"Adding Texture Quality setting...");
					SettingsHandler.Instance.AddSetting((Setting)(object)new TextureQualitySetting());
					Logger.LogInfo((object)"Adding Shadow Resolution setting...");
					SettingsHandler.Instance.AddSetting((Setting)(object)new ShadowResolutionSetting());
					Logger.LogInfo((object)"Adding LOD Bias setting...");
					SettingsHandler.Instance.AddSetting((Setting)(object)new LODBiasSetting());
					Logger.LogInfo((object)"Adding Opaque Texture setting...");
					SettingsHandler.Instance.AddSetting((Setting)(object)new OpaqueTextureSetting());
					Logger.LogInfo((object)"Adding Max Additional Lights setting...");
					SettingsHandler.Instance.AddSetting((Setting)(object)new MaxLightsSetting());
					Logger.LogInfo((object)"Adding Dynamic Batching setting...");
					SettingsHandler.Instance.AddSetting((Setting)(object)new DynamicBatchingSetting());
					Logger.LogInfo((object)"Adding Culling Distance setting...");
					SettingsHandler.Instance.AddSetting((Setting)(object)new CullingDistanceSetting());
					settingsAdded = true;
					Logger.LogInfo((object)"HDPeak settings added successfully!");
					Logger.LogInfo((object)"Available settings: Anti-Aliasing, Anisotropic Filtering, Texture Quality, Shadow Resolution, LOD Bias, Opaque Texture, Max Additional Lights, Dynamic Batching, Culling Distance");
					Logger.LogInfo((object)$"Settings added: {settingsAdded}");
				}
				catch (Exception ex)
				{
					Logger.LogError((object)("Error adding settings: " + ex.Message));
				}
			}
		}
	}
}
namespace HDPeak.Patches
{
	[HarmonyPatch]
	public static class MainCameraPatches
	{
		private static bool needsUpdate = false;

		private static int? customFarClipPlane = null;

		private static readonly FieldRef<MainCamera, Camera> CamRef = AccessTools.FieldRefAccess<MainCamera, Camera>("cam");

		[HarmonyPatch(typeof(MainCamera), "Awake")]
		[HarmonyPostfix]
		public static void Awake(MainCamera __instance)
		{
			UpdateCameraFarClipPlane(__instance);
		}

		[HarmonyPatch(typeof(MainCamera), "LateUpdate")]
		[HarmonyPostfix]
		public static void LateUpdate(MainCamera __instance)
		{
			if (needsUpdate)
			{
				UpdateCameraFarClipPlane(__instance);
			}
		}

		private static void UpdateCameraFarClipPlane(MainCamera instance)
		{
			Camera val = CamRef.Invoke(instance);
			if ((Object)(object)val != (Object)null && customFarClipPlane.HasValue)
			{
				val.farClipPlane = customFarClipPlane.Value;
				needsUpdate = false;
				HDPeakPlugin.Logger.LogInfo((object)$"Camera far clip plane was updated to {customFarClipPlane.Value}");
			}
		}

		internal static void SetFarClipDistance(int value)
		{
			customFarClipPlane = value;
			needsUpdate = true;
			HDPeakPlugin.Logger.LogInfo((object)"Updating culling distance");
		}
	}
}
namespace HDPeak.Settings
{
	public enum AntialiasingMode
	{
		Off,
		MSAA2x,
		MSAA4x,
		MSAA8x
	}
	public enum AnisotropicFilteringMode
	{
		Disable,
		Enable,
		ForceEnable
	}
	public enum TextureQualityMode
	{
		VeryLow,
		Low,
		Medium,
		High,
		VeryHigh
	}
	public enum ShadowResolutionMode
	{
		VeryLow,
		Low,
		Medium,
		High,
		VeryHigh,
		Ultra
	}
	public enum OpaqueTextureMode
	{
		Disabled,
		Enabled
	}
	public enum MaxLightsMode
	{
		VeryLow,
		Low,
		Medium,
		High,
		VeryHigh
	}
	public enum DynamicBatchingMode
	{
		Disabled,
		Enabled
	}
	[ExtenderSetting("HDPeak", "Anti-Aliasing")]
	public class AntiAliasingSetting : ExtenderEnumSetting<AntialiasingMode>
	{
		protected override AntialiasingMode GetDefaultValue()
		{
			return AntialiasingMode.MSAA2x;
		}

		public override List<LocalizedString> GetLocalizedChoices()
		{
			return null;
		}

		public AntiAliasingSetting()
			: base((Action<AntialiasingMode>)delegate(AntialiasingMode Value)
			{
				RenderPipelineAsset renderPipeline = QualitySettings.renderPipeline;
				UniversalRenderPipelineAsset val = (UniversalRenderPipelineAsset)(object)((renderPipeline is UniversalRenderPipelineAsset) ? renderPipeline : null);
				if ((Object)(object)val == (Object)null)
				{
					switch (Value)
					{
					case AntialiasingMode.Off:
						QualitySettings.antiAliasing = 0;
						break;
					case AntialiasingMode.MSAA2x:
						QualitySettings.antiAliasing = 2;
						break;
					case AntialiasingMode.MSAA4x:
						QualitySettings.antiAliasing = 4;
						break;
					case AntialiasingMode.MSAA8x:
						QualitySettings.antiAliasing = 8;
						break;
					default:
						QualitySettings.antiAliasing = 2;
						break;
					}
				}
				else
				{
					switch (Value)
					{
					case AntialiasingMode.Off:
						val.msaaSampleCount = 1;
						break;
					case AntialiasingMode.MSAA2x:
						val.msaaSampleCount = 2;
						break;
					case AntialiasingMode.MSAA4x:
						val.msaaSampleCount = 4;
						break;
					case AntialiasingMode.MSAA8x:
						val.msaaSampleCount = 8;
						break;
					default:
						val.msaaSampleCount = 2;
						break;
					}
				}
			})
		{
		}
	}
	[ExtenderSetting("HDPeak", "Anisotropic Filtering")]
	public class AnisotropicFilteringSetting : ExtenderEnumSetting<AnisotropicFilteringMode>
	{
		protected override AnisotropicFilteringMode GetDefaultValue()
		{
			return AnisotropicFilteringMode.Enable;
		}

		public override List<LocalizedString> GetLocalizedChoices()
		{
			return null;
		}

		public AnisotropicFilteringSetting()
			: base((Action<AnisotropicFilteringMode>)delegate(AnisotropicFilteringMode Value)
			{
				switch (Value)
				{
				case AnisotropicFilteringMode.Disable:
					QualitySettings.anisotropicFiltering = (AnisotropicFiltering)0;
					break;
				case AnisotropicFilteringMode.Enable:
					QualitySettings.anisotropicFiltering = (AnisotropicFiltering)1;
					break;
				case AnisotropicFilteringMode.ForceEnable:
					QualitySettings.anisotropicFiltering = (AnisotropicFiltering)2;
					break;
				default:
					QualitySettings.anisotropicFiltering = (AnisotropicFiltering)1;
					break;
				}
			})
		{
		}
	}
	[ExtenderSetting("HDPeak", "Texture Quality")]
	public class TextureQualitySetting : ExtenderEnumSetting<TextureQualityMode>
	{
		protected override TextureQualityMode GetDefaultValue()
		{
			return TextureQualityMode.High;
		}

		public override List<LocalizedString> GetLocalizedChoices()
		{
			return null;
		}

		public TextureQualitySetting()
			: base((Action<TextureQualityMode>)delegate(TextureQualityMode Value)
			{
				switch (Value)
				{
				case TextureQualityMode.VeryHigh:
					QualitySettings.globalTextureMipmapLimit = 0;
					break;
				case TextureQualityMode.High:
					QualitySettings.globalTextureMipmapLimit = 1;
					break;
				case TextureQualityMode.Medium:
					QualitySettings.globalTextureMipmapLimit = 2;
					break;
				case TextureQualityMode.Low:
					QualitySettings.globalTextureMipmapLimit = 3;
					break;
				case TextureQualityMode.VeryLow:
					QualitySettings.globalTextureMipmapLimit = 4;
					break;
				default:
					QualitySettings.globalTextureMipmapLimit = 1;
					break;
				}
			})
		{
		}
	}
	[ExtenderSetting("HDPeak", "Shadow Resolution")]
	public class ShadowResolutionSetting : ExtenderEnumSetting<ShadowResolutionMode>
	{
		protected override ShadowResolutionMode GetDefaultValue()
		{
			return ShadowResolutionMode.Medium;
		}

		public override List<LocalizedString> GetLocalizedChoices()
		{
			return null;
		}

		public ShadowResolutionSetting()
			: base((Action<ShadowResolutionMode>)delegate(ShadowResolutionMode Value)
			{
				RenderPipelineAsset renderPipeline = QualitySettings.renderPipeline;
				UniversalRenderPipelineAsset val = (UniversalRenderPipelineAsset)(object)((renderPipeline is UniversalRenderPipelineAsset) ? renderPipeline : null);
				if ((Object)(object)val != (Object)null)
				{
					switch (Value)
					{
					case ShadowResolutionMode.VeryLow:
						val.mainLightShadowmapResolution = 256;
						break;
					case ShadowResolutionMode.Low:
						val.mainLightShadowmapResolution = 512;
						break;
					case ShadowResolutionMode.Medium:
						val.mainLightShadowmapResolution = 1024;
						break;
					case ShadowResolutionMode.High:
						val.mainLightShadowmapResolution = 2048;
						break;
					case ShadowResolutionMode.VeryHigh:
						val.mainLightShadowmapResolution = 4096;
						break;
					case ShadowResolutionMode.Ultra:
						val.mainLightShadowmapResolution = 8192;
						break;
					default:
						val.mainLightShadowmapResolution = 1024;
						break;
					}
				}
			})
		{
		}
	}
	[ExtenderSetting("HDPeak", "LOD Bias")]
	public class LODBiasSetting : ExtenderFloatSetting
	{
		protected override float GetDefaultValue()
		{
			return 0f;
		}

		protected override float2 GetMinMaxValue()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new float2(0.5f, 2f);
		}

		public LODBiasSetting()
			: base((Action<float>)delegate(float Value)
			{
				QualitySettings.lodBias = Value;
			})
		{
		}
	}
	[ExtenderSetting("HDPeak", "Opaque Texture")]
	public class OpaqueTextureSetting : ExtenderEnumSetting<OpaqueTextureMode>
	{
		protected override OpaqueTextureMode GetDefaultValue()
		{
			return OpaqueTextureMode.Disabled;
		}

		public override List<LocalizedString> GetLocalizedChoices()
		{
			return null;
		}

		public OpaqueTextureSetting()
			: base((Action<OpaqueTextureMode>)delegate(OpaqueTextureMode Value)
			{
				RenderPipelineAsset renderPipeline = QualitySettings.renderPipeline;
				UniversalRenderPipelineAsset val = (UniversalRenderPipelineAsset)(object)((renderPipeline is UniversalRenderPipelineAsset) ? renderPipeline : null);
				if ((Object)(object)val != (Object)null)
				{
					bool supportsCameraOpaqueTexture = Value == OpaqueTextureMode.Enabled;
					val.supportsCameraOpaqueTexture = supportsCameraOpaqueTexture;
				}
			})
		{
		}
	}
	[ExtenderSetting("HDPeak", "Max Additional Lights")]
	public class MaxLightsSetting : ExtenderEnumSetting<MaxLightsMode>
	{
		protected override MaxLightsMode GetDefaultValue()
		{
			return MaxLightsMode.Medium;
		}

		public override List<LocalizedString> GetLocalizedChoices()
		{
			return null;
		}

		public MaxLightsSetting()
			: base((Action<MaxLightsMode>)delegate(MaxLightsMode Value)
			{
				RenderPipelineAsset renderPipeline = QualitySettings.renderPipeline;
				UniversalRenderPipelineAsset val = (UniversalRenderPipelineAsset)(object)((renderPipeline is UniversalRenderPipelineAsset) ? renderPipeline : null);
				if ((Object)(object)val != (Object)null)
				{
					switch (Value)
					{
					case MaxLightsMode.VeryLow:
						val.maxAdditionalLightsCount = 1;
						break;
					case MaxLightsMode.Low:
						val.maxAdditionalLightsCount = 2;
						break;
					case MaxLightsMode.Medium:
						val.maxAdditionalLightsCount = 4;
						break;
					case MaxLightsMode.High:
						val.maxAdditionalLightsCount = 6;
						break;
					case MaxLightsMode.VeryHigh:
						val.maxAdditionalLightsCount = 8;
						break;
					default:
						val.maxAdditionalLightsCount = 4;
						break;
					}
				}
			})
		{
		}
	}
	[ExtenderSetting("HDPeak", "Dynamic Batching")]
	public class DynamicBatchingSetting : ExtenderEnumSetting<DynamicBatchingMode>
	{
		protected override DynamicBatchingMode GetDefaultValue()
		{
			return DynamicBatchingMode.Disabled;
		}

		public override List<LocalizedString> GetLocalizedChoices()
		{
			return null;
		}

		public DynamicBatchingSetting()
			: base((Action<DynamicBatchingMode>)delegate(DynamicBatchingMode Value)
			{
				RenderPipelineAsset renderPipeline = QualitySettings.renderPipeline;
				UniversalRenderPipelineAsset val = (UniversalRenderPipelineAsset)(object)((renderPipeline is UniversalRenderPipelineAsset) ? renderPipeline : null);
				if ((Object)(object)val != (Object)null)
				{
					bool supportsDynamicBatching = Value == DynamicBatchingMode.Enabled;
					val.supportsDynamicBatching = supportsDynamicBatching;
				}
			})
		{
		}
	}
	[ExtenderSetting("HDPeak", "Culling Distance")]
	public class CullingDistanceSetting : ExtenderFloatSetting
	{
		protected override float GetDefaultValue()
		{
			return 1500f;
		}

		protected override float2 GetMinMaxValue()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return new float2(50f, 1500f);
		}

		public override void Load(ISettingsSaveLoad loader)
		{
			((FloatSetting)this).Load(loader);
			MainCameraPatches.SetFarClipDistance((int)((FloatSetting)this).Value);
		}

		public CullingDistanceSetting()
			: base((Action<float>)delegate(float Value)
			{
				MainCameraPatches.SetFarClipDistance((int)Value);
			})
		{
		}
	}
}