using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
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.Logging;
using HDPeak.Settings;
using Microsoft.CodeAnalysis;
using TMPro;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.Localization;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
using UnityEngine.SceneManagement;
using Zorro.Settings;
using Zorro.UI;

[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.1.0")]
[assembly: AssemblyInformationalVersion("1.0.0+ff28d96789e667f3d6e4df666ee231dbb7354b32")]
[assembly: AssemblyProduct("HDPeak")]
[assembly: AssemblyTitle("HDPeak - Advanced Graphics Settings")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.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.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.1.0";
	}
	[BepInPlugin("com.nozz.hdpeak", "HDPeak", "1.1.0")]
	public class HDPeakPlugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		private GameObject buttonSrc;

		private bool settingsAdded;

		private Coroutine updateTabsRoutine;

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"Plugin com.nozz.hdpeak is loaded!");
			LoadLocalizationData();
			HDPeakSettingsRegistry.Register("HDPeak");
		}

		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());
					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");
					Logger.LogInfo((object)$"Settings added: {settingsAdded}");
				}
				catch (Exception ex)
				{
					Logger.LogError((object)("Error adding settings: " + ex.Message));
				}
			}
		}

		private void OnEnable()
		{
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		private void OnDisable()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			if (updateTabsRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(updateTabsRoutine);
				updateTabsRoutine = null;
			}
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (updateTabsRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(updateTabsRoutine);
				updateTabsRoutine = null;
			}
			updateTabsRoutine = ((MonoBehaviour)this).StartCoroutine(UpdateTabs(scene));
		}

		private IEnumerator UpdateTabs(Scene scene)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogInfo((object)("Scene loaded: " + ((Scene)(ref scene)).name));
			while ((Object)(object)buttonSrc == (Object)null)
			{
				List<SettingsTABSButton> list = FindAllInScene(scene);
				if (list.Count != 0)
				{
					buttonSrc = ((Component)list[0]).gameObject;
				}
				yield return (object)new WaitForSeconds(0.05f);
			}
			if (!((Object)(object)buttonSrc != (Object)null))
			{
				yield break;
			}
			Logger.LogInfo((object)"Found TABS/General");
			foreach (KeyValuePair<string, SettingsCategory> page in HDPeakSettingsRegistry.GetPages())
			{
				string key = page.Key;
				SettingsCategory value = page.Value;
				Logger.LogInfo((object)$"Creating {key} with category {value}");
				SettingsTABSButton component = Object.Instantiate<GameObject>(buttonSrc, buttonSrc.transform.parent).GetComponent<SettingsTABSButton>();
				component.category = value;
				((TMP_Text)((TAB_Button)component).text).text = LocalizedText.GetText("HDPEAK_TAB", true);
			}
		}

		public static List<SettingsTABSButton> FindAllInScene(Scene scene)
		{
			List<SettingsTABSButton> list = new List<SettingsTABSButton>();
			GameObject[] rootGameObjects = ((Scene)(ref scene)).GetRootGameObjects();
			for (int i = 0; i < rootGameObjects.Length; i++)
			{
				SettingsTABSButton[] componentsInChildren = rootGameObjects[i].GetComponentsInChildren<SettingsTABSButton>();
				list.AddRange(componentsInChildren);
			}
			return list;
		}

		private void LoadLocalizationData()
		{
			try
			{
				Assembly executingAssembly = Assembly.GetExecutingAssembly();
				string text = "HDPeak.assets.Resources.Localization.Localized_Text.csv";
				using Stream stream = executingAssembly.GetManifestResourceStream(text);
				if (stream == null)
				{
					Logger.LogError((object)("Could not find embedded resource: " + text));
					return;
				}
				using StreamReader streamReader = new StreamReader(stream);
				string csvContent = streamReader.ReadToEnd();
				Logger.LogInfo((object)"Successfully loaded HDPeak localization CSV");
				ParseAndAddLocalizationData(csvContent);
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("Error loading localization data: " + ex.Message));
			}
		}

		private void ParseAndAddLocalizationData(string csvContent)
		{
			try
			{
				string[] array = csvContent.Split(new char[1] { '\n' });
				if (array.Length < 2)
				{
					Logger.LogError((object)"Invalid CSV format: not enough lines");
					return;
				}
				string[] array2 = array[0].Split(new char[1] { ',' });
				Dictionary<string, int> dictionary = new Dictionary<string, int>();
				for (int i = 1; i < array2.Length; i++)
				{
					dictionary[array2[i].Trim()] = i;
				}
				Logger.LogInfo((object)$"Found {dictionary.Count} languages in localization file");
				for (int j = 1; j < array.Length; j++)
				{
					string text = array[j].Trim();
					if (string.IsNullOrEmpty(text))
					{
						continue;
					}
					string[] array3 = ParseCSVLine(text);
					if (array3.Length < 2)
					{
						continue;
					}
					string text2 = array3[0].Trim();
					if (string.IsNullOrEmpty(text2))
					{
						continue;
					}
					foreach (KeyValuePair<string, int> item in dictionary)
					{
						if (item.Value < array3.Length)
						{
							string value = array3[item.Value].Trim();
							if (!string.IsNullOrEmpty(value))
							{
								AddToGameLocalization(text2, value, item.Key);
							}
						}
					}
				}
				Logger.LogInfo((object)"Successfully parsed and added HDPeak localization data");
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("Error parsing localization CSV: " + ex.Message));
			}
		}

		private string[] ParseCSVLine(string line)
		{
			List<string> list = new List<string>();
			bool flag = false;
			string text = "";
			for (int i = 0; i < line.Length; i++)
			{
				char c = line[i];
				switch (c)
				{
				case '"':
					flag = !flag;
					continue;
				case ',':
					if (!flag)
					{
						list.Add(text);
						text = "";
						continue;
					}
					break;
				}
				text += c;
			}
			list.Add(text);
			return list.ToArray();
		}

		private void AddToGameLocalization(string key, string value, string language)
		{
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected I4, but got Unknown
			try
			{
				Dictionary<string, Language> dictionary = new Dictionary<string, Language>
				{
					{
						"English",
						(Language)0
					},
					{
						"French",
						(Language)1
					},
					{
						"Italian",
						(Language)2
					},
					{
						"German",
						(Language)3
					},
					{
						"SpanishSpain",
						(Language)4
					},
					{
						"SpanishLatam",
						(Language)5
					},
					{
						"BRPortuguese",
						(Language)6
					},
					{
						"Russian",
						(Language)7
					},
					{
						"Ukrainian",
						(Language)8
					},
					{
						"SimplifiedChinese",
						(Language)9
					},
					{
						"TraditionalChinese",
						(Language)10
					},
					{
						"Japanese",
						(Language)11
					},
					{
						"Korean",
						(Language)12
					}
				};
				if (!dictionary.ContainsKey(language))
				{
					Logger.LogWarning((object)("Unknown language: " + language));
					return;
				}
				int num = (int)dictionary[language];
				try
				{
					FieldInfo field = typeof(LocalizedText).GetField("MAIN_TABLE", BindingFlags.Static | BindingFlags.NonPublic);
					if (field != null)
					{
						if (field.GetValue(null) is Dictionary<string, List<string>> dictionary2)
						{
							if (!dictionary2.ContainsKey(key))
							{
								List<string> list = new List<string>();
								for (int i = 0; i < 13; i++)
								{
									list.Add("");
								}
								dictionary2[key] = list;
							}
							List<string> list2 = dictionary2[key];
							if (num < list2.Count)
							{
								list2[num] = value;
								Logger.LogDebug((object)("Added localization: " + key + " = " + value + " for " + language));
							}
							else
							{
								Logger.LogWarning((object)$"Language index {num} out of range for key {key}");
							}
						}
						else
						{
							Logger.LogWarning((object)"Main table is null, trying to initialize it");
							LocalizedText.TryInitTables();
						}
					}
					else
					{
						Logger.LogWarning((object)"Could not find MAIN_TABLE field in LocalizedText");
					}
				}
				catch (Exception ex)
				{
					Logger.LogError((object)("Error accessing LocalizedText table: " + ex.Message));
				}
			}
			catch (Exception ex2)
			{
				Logger.LogError((object)("Error adding localization entry " + key + ": " + ex2.Message));
			}
		}
	}
	public class HDPeakSettingsRegistry
	{
		internal static Dictionary<string, SettingsCategory> nameToCategoryId = new Dictionary<string, SettingsCategory>();

		public static void Register(string name)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (!nameToCategoryId.ContainsKey(name))
			{
				SettingsCategory val = Enum.GetValues(typeof(SettingsCategory)).Cast<SettingsCategory>().Max();
				if (nameToCategoryId.Count != 0)
				{
					val = nameToCategoryId.Values.Max();
				}
				nameToCategoryId[name] = (SettingsCategory)(val + 1);
			}
		}

		public static string GetPageId(string name)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			SettingsCategory val = nameToCategoryId[name];
			return ((object)(SettingsCategory)(ref val)).ToString();
		}

		public static Dictionary<string, SettingsCategory> GetPages()
		{
			return nameToCategoryId;
		}
	}
}
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
	}
	public class AntiAliasingSetting : EnumSetting<AntialiasingMode>, IExposedSetting
	{
		public string GetDisplayName()
		{
			return LocalizedText.GetText("HDPEAK_ANTIALIASING", true);
		}

		public string GetCategory()
		{
			return HDPeakSettingsRegistry.GetPageId("HDPeak");
		}

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

		public override List<string> GetUnlocalizedChoices()
		{
			return new List<string>
			{
				LocalizedText.GetText("HDPEAK_ANTIALIASING_OFF", true),
				LocalizedText.GetText("HDPEAK_ANTIALIASING_MSAA2X", true),
				LocalizedText.GetText("HDPEAK_ANTIALIASING_MSAA4X", true),
				LocalizedText.GetText("HDPEAK_ANTIALIASING_MSAA8X", true)
			};
		}

		protected override AntialiasingMode GetDefaultValue()
		{
			return AntialiasingMode.MSAA2x;
		}

		public override void ApplyValue()
		{
			RenderPipelineAsset renderPipeline = QualitySettings.renderPipeline;
			UniversalRenderPipelineAsset val = (UniversalRenderPipelineAsset)(object)((renderPipeline is UniversalRenderPipelineAsset) ? renderPipeline : null);
			if ((Object)(object)val == (Object)null)
			{
				switch (base.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 (base.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;
				}
			}
		}
	}
	public class AnisotropicFilteringSetting : EnumSetting<AnisotropicFilteringMode>, IExposedSetting
	{
		public string GetDisplayName()
		{
			return LocalizedText.GetText("HDPEAK_ANISOTROPIC_FILTERING", true);
		}

		public string GetCategory()
		{
			return HDPeakSettingsRegistry.GetPageId("HDPeak");
		}

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

		public override List<string> GetUnlocalizedChoices()
		{
			return new List<string>
			{
				LocalizedText.GetText("HDPEAK_ANISOTROPIC_FILTERING_DISABLE", true),
				LocalizedText.GetText("HDPEAK_ANISOTROPIC_FILTERING_ENABLE", true),
				LocalizedText.GetText("HDPEAK_ANISOTROPIC_FILTERING_FORCE_ENABLE", true)
			};
		}

		protected override AnisotropicFilteringMode GetDefaultValue()
		{
			return AnisotropicFilteringMode.Enable;
		}

		public override void ApplyValue()
		{
			switch (base.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;
			}
		}
	}
	public class TextureQualitySetting : EnumSetting<TextureQualityMode>, IExposedSetting
	{
		public string GetDisplayName()
		{
			return LocalizedText.GetText("HDPEAK_TEXTURE_QUALITY", true);
		}

		public string GetCategory()
		{
			return HDPeakSettingsRegistry.GetPageId("HDPeak");
		}

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

		public override List<string> GetUnlocalizedChoices()
		{
			return new List<string>
			{
				LocalizedText.GetText("HDPEAK_TEXTURE_QUALITY_VERY_LOW", true),
				LocalizedText.GetText("HDPEAK_TEXTURE_QUALITY_LOW", true),
				LocalizedText.GetText("HDPEAK_TEXTURE_QUALITY_MEDIUM", true),
				LocalizedText.GetText("HDPEAK_TEXTURE_QUALITY_HIGH", true),
				LocalizedText.GetText("HDPEAK_TEXTURE_QUALITY_VERY_HIGH", true)
			};
		}

		protected override TextureQualityMode GetDefaultValue()
		{
			return TextureQualityMode.High;
		}

		public override void ApplyValue()
		{
			switch (base.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;
			}
		}
	}
	public class ShadowResolutionSetting : EnumSetting<ShadowResolutionMode>, IExposedSetting
	{
		public string GetDisplayName()
		{
			return LocalizedText.GetText("HDPEAK_SHADOW_RESOLUTION", true);
		}

		public string GetCategory()
		{
			return HDPeakSettingsRegistry.GetPageId("HDPeak");
		}

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

		public override List<string> GetUnlocalizedChoices()
		{
			return new List<string>
			{
				LocalizedText.GetText("HDPEAK_SHADOW_RESOLUTION_VERY_LOW", true),
				LocalizedText.GetText("HDPEAK_SHADOW_RESOLUTION_LOW", true),
				LocalizedText.GetText("HDPEAK_SHADOW_RESOLUTION_MEDIUM", true),
				LocalizedText.GetText("HDPEAK_SHADOW_RESOLUTION_HIGH", true),
				LocalizedText.GetText("HDPEAK_SHADOW_RESOLUTION_VERY_HIGH", true),
				LocalizedText.GetText("HDPEAK_SHADOW_RESOLUTION_ULTRA", true)
			};
		}

		protected override ShadowResolutionMode GetDefaultValue()
		{
			return ShadowResolutionMode.Medium;
		}

		public override void ApplyValue()
		{
			RenderPipelineAsset renderPipeline = QualitySettings.renderPipeline;
			UniversalRenderPipelineAsset val = (UniversalRenderPipelineAsset)(object)((renderPipeline is UniversalRenderPipelineAsset) ? renderPipeline : null);
			if ((Object)(object)val != (Object)null)
			{
				switch (base.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;
				}
			}
		}
	}
	public class LODBiasSetting : FloatSetting, IExposedSetting
	{
		public string GetDisplayName()
		{
			return LocalizedText.GetText("HDPEAK_LOD_BIAS", true);
		}

		public string GetCategory()
		{
			return HDPeakSettingsRegistry.GetPageId("HDPeak");
		}

		protected override float GetDefaultValue()
		{
			return 1f;
		}

		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 override void ApplyValue()
		{
			QualitySettings.lodBias = ((FloatSetting)this).Value;
		}
	}
	public class OpaqueTextureSetting : EnumSetting<OpaqueTextureMode>, IExposedSetting
	{
		public string GetDisplayName()
		{
			return LocalizedText.GetText("HDPEAK_OPAQUE_TEXTURE", true);
		}

		public string GetCategory()
		{
			return HDPeakSettingsRegistry.GetPageId("HDPeak");
		}

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

		public override List<string> GetUnlocalizedChoices()
		{
			return new List<string>
			{
				LocalizedText.GetText("HDPEAK_OPAQUE_TEXTURE_DISABLED", true),
				LocalizedText.GetText("HDPEAK_OPAQUE_TEXTURE_ENABLED", true)
			};
		}

		protected override OpaqueTextureMode GetDefaultValue()
		{
			return OpaqueTextureMode.Disabled;
		}

		public override void ApplyValue()
		{
			RenderPipelineAsset renderPipeline = QualitySettings.renderPipeline;
			UniversalRenderPipelineAsset val = (UniversalRenderPipelineAsset)(object)((renderPipeline is UniversalRenderPipelineAsset) ? renderPipeline : null);
			if ((Object)(object)val != (Object)null)
			{
				bool supportsCameraOpaqueTexture = base.Value == OpaqueTextureMode.Enabled;
				val.supportsCameraOpaqueTexture = supportsCameraOpaqueTexture;
			}
		}
	}
	public class MaxLightsSetting : EnumSetting<MaxLightsMode>, IExposedSetting
	{
		public string GetDisplayName()
		{
			return LocalizedText.GetText("HDPEAK_MAX_ADDITIONAL_LIGHTS", true);
		}

		public string GetCategory()
		{
			return HDPeakSettingsRegistry.GetPageId("HDPeak");
		}

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

		public override List<string> GetUnlocalizedChoices()
		{
			return new List<string>
			{
				LocalizedText.GetText("HDPEAK_MAX_ADDITIONAL_LIGHTS_VERY_LOW", true),
				LocalizedText.GetText("HDPEAK_MAX_ADDITIONAL_LIGHTS_LOW", true),
				LocalizedText.GetText("HDPEAK_MAX_ADDITIONAL_LIGHTS_MEDIUM", true),
				LocalizedText.GetText("HDPEAK_MAX_ADDITIONAL_LIGHTS_HIGH", true),
				LocalizedText.GetText("HDPEAK_MAX_ADDITIONAL_LIGHTS_VERY_HIGH", true)
			};
		}

		protected override MaxLightsMode GetDefaultValue()
		{
			return MaxLightsMode.Medium;
		}

		public override void ApplyValue()
		{
			RenderPipelineAsset renderPipeline = QualitySettings.renderPipeline;
			UniversalRenderPipelineAsset val = (UniversalRenderPipelineAsset)(object)((renderPipeline is UniversalRenderPipelineAsset) ? renderPipeline : null);
			if ((Object)(object)val != (Object)null)
			{
				switch (base.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;
				}
			}
		}
	}
	public class DynamicBatchingSetting : EnumSetting<DynamicBatchingMode>, IExposedSetting
	{
		public string GetDisplayName()
		{
			return LocalizedText.GetText("HDPEAK_DYNAMIC_BATCHING", true);
		}

		public string GetCategory()
		{
			return HDPeakSettingsRegistry.GetPageId("HDPeak");
		}

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

		public override List<string> GetUnlocalizedChoices()
		{
			return new List<string>
			{
				LocalizedText.GetText("HDPEAK_DYNAMIC_BATCHING_DISABLED", true),
				LocalizedText.GetText("HDPEAK_DYNAMIC_BATCHING_ENABLED", true)
			};
		}

		protected override DynamicBatchingMode GetDefaultValue()
		{
			return DynamicBatchingMode.Disabled;
		}

		public override void ApplyValue()
		{
			RenderPipelineAsset renderPipeline = QualitySettings.renderPipeline;
			UniversalRenderPipelineAsset val = (UniversalRenderPipelineAsset)(object)((renderPipeline is UniversalRenderPipelineAsset) ? renderPipeline : null);
			if ((Object)(object)val != (Object)null)
			{
				bool supportsDynamicBatching = base.Value == DynamicBatchingMode.Enabled;
				val.supportsDynamicBatching = supportsDynamicBatching;
			}
		}
	}
}