path: root/Client/Assets/Scripts/XMainClient/XQualitySetting.cs

using System;
using System.Collections.Generic;
using KKSG;
using UnityEngine;
using XUtliPoolLib;

namespace XMainClient
{
	public class XQualitySetting
	{
		private static XQualitySetting.XSetting[] _settings = new XQualitySetting.XSetting[]
		{
			new XQualitySetting.XSetting(),
			new XQualitySetting.XSetting(),
			new XQualitySetting.XSetting(),
			new XQualitySetting.XSetting()
		};

		private static float[] _hallLayerculldistance = new float[32];

		private static float[] _layerculldistance = new float[32];

		public static Light mainLight = null;

		public static IFxPro fxPro = null;

		public static int VisibleRoleCountPerLevel = 5;

		private static int _VisibleRoleCount = 20;

		private static int _QualityLevel = -1;

		private static int _HardwareQualityLevel = -1;

		private static bool _IsPcOrSimulator = false;

		private static XQualitySetting.XSetting _CurrentSetting = null;

		public static bool _InHall = false;

		public static bool _CastShadow = false;

		public static float _FadeDistance = 81f;

		private static int _flag = 0;

		private static IEnvSetting _envSet;

		public static int width = 1136;

		public static int height = 640;

		public static float maxResolution = 640f;

		public static int _InvisiblityLayerOffset = 0;

		public static int _QualityHighLayerOffset = 0;

		public static int _QualityNormalLayerOffset = 0;

		public static int _UILayerOffset = 0;

		public static int _DefaultLayerOffset = 0;

		public static int InVisiblityLayer = 31;

		public static int UILayer = 5;

		public static int TerrainLayer = 9;

		public static float _WindSpeedFactor = 1f;

		public static int lowLevel = XFastEnumIntEqualityComparer<XQualitySetting.ESetting>.ToInt(XQualitySetting.ESetting.ELow);

		public static int normalLevel = XFastEnumIntEqualityComparer<XQualitySetting.ESetting>.ToInt(XQualitySetting.ESetting.ENormal);

		public static int heighLevel = XFastEnumIntEqualityComparer<XQualitySetting.ESetting>.ToInt(XQualitySetting.ESetting.EHeigh);

		public static int veryHighLevel = XQualitySetting.heighLevel + 1;

		public static int numLevel = XFastEnumIntEqualityComparer<XQualitySetting.ESetting>.ToInt(XQualitySetting.ESetting.ENum);

		public static int lowResolution = XFastEnumIntEqualityComparer<XQualitySetting.EResolution>.ToInt(XQualitySetting.EResolution.ELow);

		public static int normalResolution = XFastEnumIntEqualityComparer<XQualitySetting.EResolution>.ToInt(XQualitySetting.EResolution.ENormal);

		public static int heighResolution = XFastEnumIntEqualityComparer<XQualitySetting.EResolution>.ToInt(XQualitySetting.EResolution.EHeigh);

		public enum ESetting
		{
			ELow,
			ENormal,
			EHeigh,
			EVeryHeigh,
			ENum
		}

		public enum EResolution
		{
			ELow,
			ENormal,
			EHeigh,
			ENum
		}

		public class XSetting
		{
			public bool _bloom = false;

			public float _CameraHall = 130f;

			public float _CameraWorld = 80f;

			public BlendWeights bw = (BlendWeights)1;

			public int _CullMask = -1;

			public bool _EnableFog = true;

			public int _ShaderLod = 600;

			public int _MaxParticelCount = 10;
		}

		public static void Init()
		{
			XQualitySetting._InvisiblityLayerOffset = 1 << LayerMask.NameToLayer("InVisiblity");
			XQualitySetting._QualityHighLayerOffset = 1 << LayerMask.NameToLayer("QualityHigh");
			XQualitySetting._QualityNormalLayerOffset = 1 << LayerMask.NameToLayer("QualityNormal");
			XQualitySetting._UILayerOffset = 1 << LayerMask.NameToLayer("UI");
			XQualitySetting._DefaultLayerOffset = 1 << LayerMask.NameToLayer("Default");
			XQualitySetting.XSetting xsetting = XQualitySetting._settings[0];
			xsetting._bloom = false;
			xsetting._CameraHall = 130f;
			xsetting._CameraWorld = 80f;
			xsetting.bw = (BlendWeights)1;
			xsetting._CullMask = ~(XQualitySetting._QualityHighLayerOffset | XQualitySetting._QualityNormalLayerOffset);
			xsetting._EnableFog = false;
			xsetting._ShaderLod = 100;
			xsetting._MaxParticelCount = 3;
			XQualitySetting.XSetting xsetting2 = XQualitySetting._settings[1];
			xsetting2._bloom = false;
			xsetting2._CameraHall = 140f;
			xsetting2._CameraWorld = 80f;
			xsetting2.bw = (BlendWeights)2;
			xsetting2._CullMask = (~XQualitySetting._QualityHighLayerOffset | XQualitySetting._QualityNormalLayerOffset);
			xsetting2._EnableFog = true;
			xsetting2._ShaderLod = 200;
			xsetting2._MaxParticelCount = 6;
			XQualitySetting.XSetting xsetting3 = XQualitySetting._settings[2];
			xsetting3._bloom = false;
			xsetting3._CameraHall = 150f;
			xsetting3._CameraWorld = 90f;
			xsetting3.bw = (BlendWeights)2;
			xsetting3._CullMask = (XQualitySetting._QualityHighLayerOffset | XQualitySetting._QualityNormalLayerOffset);
			xsetting3._EnableFog = true;
			xsetting3._ShaderLod = 600;
			xsetting3._MaxParticelCount = 50;
			XQualitySetting.XSetting xsetting4 = XQualitySetting._settings[3];
			xsetting4._bloom = true;
			xsetting4._CameraHall = 150f;
			xsetting4._CameraWorld = 90f;
			xsetting4.bw = (BlendWeights)4;
			xsetting4._CullMask = (XQualitySetting._QualityHighLayerOffset | XQualitySetting._QualityNormalLayerOffset);
			xsetting4._EnableFog = true;
			xsetting4._ShaderLod = 600;
			xsetting4._MaxParticelCount = 50;
			XQualitySetting._hallLayerculldistance[LayerMask.NameToLayer("Npc")] = 35f;
			XQualitySetting._hallLayerculldistance[LayerMask.NameToLayer("Resources")] = 35f;
			XQualitySetting._hallLayerculldistance[LayerMask.NameToLayer("QualityHigh")] = 80f;
			XQualitySetting._hallLayerculldistance[LayerMask.NameToLayer("QualityNormal")] = 50f;
			XQualitySetting._hallLayerculldistance[LayerMask.NameToLayer("QualityCullDistance")] = 20f;
			XQualitySetting._hallLayerculldistance[LayerMask.NameToLayer("Dummy")] = 25f;
			XQualitySetting._layerculldistance[LayerMask.NameToLayer("Npc")] = 40f;
			XQualitySetting._layerculldistance[LayerMask.NameToLayer("Role")] = 40f;
			XQualitySetting._layerculldistance[LayerMask.NameToLayer("Enemy")] = 40f;
			XQualitySetting._layerculldistance[LayerMask.NameToLayer("BigGuy")] = 60f;
			XQualitySetting._layerculldistance[LayerMask.NameToLayer("QualityHigh")] = 60f;
			XQualitySetting._layerculldistance[LayerMask.NameToLayer("QualityNormal")] = 40f;
			XQualitySetting._layerculldistance[LayerMask.NameToLayer("QualityCullDistance")] = 20f;
		}

		public static void SetQuality(int level, bool init = false)
		{
			bool flag = level >= 0;
			if (flag)
			{
				if (init)
				{
					QualitySettings.SetQualityLevel(2);
					XQualitySetting._IsPcOrSimulator = (level > XQualitySetting.veryHighLevel);
					XQualitySetting._HardwareQualityLevel = level;
					bool flag2 = XQualitySetting._HardwareQualityLevel == XQualitySetting.lowLevel;
					if (flag2)
					{
						QualitySettings.pixelLightCount = 0;
						QualitySettings.masterTextureLimit = 1;
						QualitySettings.anisotropicFiltering =(AnisotropicFiltering) 0;
					}
					else
					{
						QualitySettings.pixelLightCount = 1;
						QualitySettings.masterTextureLimit = 0;
						QualitySettings.anisotropicFiltering = (AnisotropicFiltering)1;
					}
					QualitySettings.particleRaycastBudget = 2;
				}
				int num = (level > XQualitySetting.veryHighLevel) ? XQualitySetting.veryHighLevel : level;
				bool flag3 = XQualitySetting._QualityLevel != num;
				XQualitySetting.XSetting xsetting;
				if (flag3)
				{
					XQualitySetting._QualityLevel = num;
					xsetting = XQualitySetting._settings[XQualitySetting._QualityLevel];
					QualitySettings.blendWeights = xsetting.bw;
				}
				else
				{
					xsetting = XQualitySetting._settings[XQualitySetting._QualityLevel];
				}
				XQualitySetting._CurrentSetting = xsetting;
			}
		}

		public static void InitResolution()
		{
			XQualitySetting.width = Screen.width;
			XQualitySetting.height = Screen.height;
			XOptionsDocument specificDocument = XDocuments.GetSpecificDocument<XOptionsDocument>(XOptionsDocument.uuID);
			bool flag = specificDocument != null;
			if (flag)
			{
				int value = specificDocument.GetValue(XOptionsDefine.OD_RESOLUTION);
				XQualitySetting.SetResolution((XQualitySetting.EResolution)value, true);
			}
		}

		public static void SetResolution(XQualitySetting.EResolution resolution, bool force = false)
		{
			bool flag = (XQualitySetting._InHall || force) && ((int)Application.platform == 11 || (int)Application.platform == 8);
			if (flag)
			{
				int num = XFastEnumIntEqualityComparer<XQualitySetting.EResolution>.ToInt(resolution);
				bool flag2 = num == XQualitySetting.heighResolution;
				if (flag2)
				{
					XQualitySetting.maxResolution = (float)XQualitySetting.height;
					Screen.SetResolution(XQualitySetting.width, XQualitySetting.height, true);
				}
				else
				{
					bool flag3 = num == XQualitySetting.normalResolution;
					if (flag3)
					{
						XQualitySetting.maxResolution = 1080f;
					}
					else
					{
						XQualitySetting.maxResolution = 720f;
					}
					float num2 = XQualitySetting.maxResolution / (float)XQualitySetting.height;
					bool flag4 = num2 > 0.75f;
					if (flag4)
					{
						num2 = 0.75f;
					}
					bool flag5 = num2 < 0.7f;
					if (flag5)
					{
						num2 = 0.7f;
					}
					Screen.SetResolution((int)((float)XQualitySetting.width * num2), (int)((float)XQualitySetting.height * num2), true);
				}
			}
		}

		public static int GetDefalutResolution()
		{
			bool flag = XQualitySetting.width > 1920;
			int result;
			if (flag)
			{
				result = XQualitySetting.normalResolution;
			}
			else
			{
				result = XQualitySetting.heighResolution;
			}
			return result;
		}

		public static int SetVisibleRoleLevel(int level)
		{
			bool flag = level < 0;
			if (flag)
			{
				level = 0;
			}
			else
			{
				bool flag2 = level > XQualitySetting.veryHighLevel;
				if (flag2)
				{
					level = XQualitySetting.veryHighLevel;
				}
			}
			XQualitySetting._VisibleRoleCount = level * XQualitySetting.VisibleRoleCountPerLevel + XQualitySetting.VisibleRoleCountPerLevel;
			return XQualitySetting._VisibleRoleCount;
		}

		public static int GetDefalutVisibleRoleLevel()
		{
			bool flag = XQualitySetting._HardwareQualityLevel == XQualitySetting.veryHighLevel;
			int result;
			if (flag)
			{
				result = XQualitySetting.veryHighLevel;
			}
			else
			{
				result = XQualitySetting._HardwareQualityLevel + 1;
			}
			return result;
		}

		public static void GetDefalutVisibleRoleCount(out int min, out int max)
		{
			min = XQualitySetting.VisibleRoleCountPerLevel;
			max = 4 * XQualitySetting.VisibleRoleCountPerLevel;
		}

		public static int GetVisibleRoleCount()
		{
			return XQualitySetting._VisibleRoleCount;
		}

		public static void PostSetQuality()
		{
			XQualitySetting._flag = 0;
			XQualitySetting.SetQuality(EFun.ECamera, XQualitySetting._QualityLevel >= XQualitySetting.heighLevel);
			XQualitySetting.SetQuality(EFun.ENpcShadow, XQualitySetting._QualityLevel >= XQualitySetting.heighLevel);
			XQualitySetting.SetQuality(EFun.ERoleShadow, XQualitySetting._QualityLevel >= XQualitySetting.normalLevel);
			XQualitySetting.SetQuality(EFun.EEnemyShadow, XQualitySetting._QualityLevel >= XQualitySetting.normalLevel);
			XQualitySetting.SetQuality(EFun.ERealTimeShadow, XQualitySetting._QualityLevel >= XQualitySetting.heighLevel && XQualitySetting._HardwareQualityLevel >= XQualitySetting.veryHighLevel && (int)Application.platform != 11);
			XQualitySetting.SetQuality(EFun.EFxPro, XQualitySetting._QualityLevel == XQualitySetting.veryHighLevel && XQualitySetting._HardwareQualityLevel >= XQualitySetting.veryHighLevel);
			XQualitySetting.SetQuality(EFun.ESceneFade, XQualitySetting._QualityLevel >= XQualitySetting.normalLevel);
			XQualitySetting.SetQuality(EFun.EFadeInOut, XQualitySetting._QualityLevel >= XQualitySetting.normalLevel);
			bool settingEnum = XSingleton<XGlobalConfig>.singleton.GetSettingEnum(ESettingConfig.ELowEffect);
			if (settingEnum)
			{
				XQualitySetting.SetQuality(EFun.ELowEffect, XQualitySetting._QualityLevel == XQualitySetting.lowLevel);
			}
			else
			{
				XQualitySetting.SetQuality(EFun.ELowEffect, false);
			}
			XQualitySetting.SetQuality(EFun.ECommonHigh, XQualitySetting._QualityLevel >= XQualitySetting.heighLevel && XQualitySetting._InHall);
		}

		public static int GetQuality()
		{
			return XQualitySetting._QualityLevel;
		}

		public static bool GetQuality(EFun fun)
		{
			return (XQualitySetting._flag & XFastEnumIntEqualityComparer<EFun>.ToInt(fun)) != 0;
		}

		public static void SetQuality(EFun fun, bool add)
		{
			if (add)
			{
				XQualitySetting._flag |= XFastEnumIntEqualityComparer<EFun>.ToInt(fun);
			}
			else
			{
				XQualitySetting._flag &= ~XFastEnumIntEqualityComparer<EFun>.ToInt(fun);
			}
		}

		public static XQualitySetting.XSetting GetCurrentQualitySetting()
		{
			return XQualitySetting._settings[XQualitySetting._QualityLevel];
		}

		public static bool SupportHighEffect()
		{
			return XQualitySetting._HardwareQualityLevel >= XQualitySetting.veryHighLevel && (int)Application.platform != 11;
		}

		public static int GetDefaultQualityLevel()
		{
			bool isPcOrSimulator = XQualitySetting._IsPcOrSimulator;
			int result;
			if (isPcOrSimulator)
			{
				result = XQualitySetting.veryHighLevel;
			}
			else
			{
				result = ((XQualitySetting._HardwareQualityLevel > XQualitySetting.heighLevel) ? XQualitySetting.heighLevel : XQualitySetting._HardwareQualityLevel);
			}
			return result;
		}

		public static void EnterScene()
		{
			XQualitySetting._InHall = false;
			XQualitySetting.PostSetQuality();
		}

		public static void EnterHall()
		{
			XQualitySetting._InHall = true;
			XQualitySetting.PostSetQuality();
		}

		public static void SwitchScene()
		{
			XQualitySetting._envSet = null;
		}

		public static void PostSceneLoad()
		{
			Shader.SetGlobalFloat("uirim", 0f);
			XQualitySetting._CastShadow = false;
			XQualitySetting.mainLight = null;
			GameObject gameObject = GameObject.Find("MainLight");
			bool flag = gameObject != null;
			if (flag)
			{
				XQualitySetting.mainLight = gameObject.GetComponent<Light>();
				bool flag2 = XQualitySetting.mainLight != null;
				if (flag2)
				{
					Color color = XQualitySetting.mainLight.color * XQualitySetting.mainLight.intensity;
					Shader.SetGlobalColor("lightColor", color);
					Vector3 vector = -gameObject.transform.forward.normalized;
					Shader.SetGlobalVector("lightDir", new Vector4(vector.x, vector.y, vector.z, 1f));
					XQualitySetting.mainLight.shadows = 0;
					bool flag3 = XQualitySetting.GetQuality(EFun.ERealTimeShadow) && !XSingleton<XScene>.singleton.IsMustTransform;
					if (flag3)
					{
						XQualitySetting._CastShadow = (gameObject.layer == XQualitySetting.TerrainLayer);
					}
					else
					{
						XQualitySetting._CastShadow = false;
					}
				}
			}
			ShadowMapInfo.EnableShadow(XQualitySetting._CastShadow);
		}

		public static void PostSetting()
		{
			DateTime now = DateTime.Now;
			int num = now.Hour * 3600 + now.Minute * 60 + now.Second;
			bool flag = XQualitySetting._envSet != null;
			if (flag)
			{
				SceneTable.RowData sceneData = XSingleton<XScene>.singleton.SceneData;
				bool flag2 = sceneData != null && sceneData.EnvSet.Count > 0;
				if (flag2)
				{
					int i = 0;
					int count = sceneData.EnvSet.Count;
					while (i < count)
					{
						bool flag3 = num >= sceneData.EnvSet[i, 0] && num < sceneData.EnvSet[i, 1];
						if (flag3)
						{
							XQualitySetting._envSet.EnableSetting(sceneData.EnvSet[i, 2]);
							break;
						}
						i++;
					}
				}
				else
				{
					XQualitySetting._envSet.EnableSetting(0);
				}
			}
			XQualitySetting._WindSpeedFactor = XSingleton<XCommon>.singleton.RandomFloat(0.5f, 2f);
			XQualitySetting.fxPro = null;
			bool flag4 = XQualitySetting._CurrentSetting != null;
			if (flag4)
			{
				Camera unityCamera = XSingleton<XScene>.singleton.GameCamera.UnityCamera;
				bool flag5 = unityCamera != null;
				if (flag5)
				{
					unityCamera.hdr = false;
					bool flag6 = XQualitySetting._InHall || XSingleton<XSceneMgr>.singleton.GetSceneType(XSingleton<XScene>.singleton.SceneID) == SceneType.SCENE_CALLBACK;
					if (flag6)
					{
						unityCamera.farClipPlane = XQualitySetting._CurrentSetting._CameraHall;
						unityCamera.cullingMask &= ~(XQualitySetting._QualityHighLayerOffset | XQualitySetting._QualityNormalLayerOffset);
						unityCamera.cullingMask |= XQualitySetting._CurrentSetting._CullMask;
						unityCamera.cullingMask &= ~XQualitySetting._InvisiblityLayerOffset;
						unityCamera.cullingMask &= ~XQualitySetting._UILayerOffset;
						unityCamera.layerCullDistances = XQualitySetting._hallLayerculldistance;
					}
					else
					{
						bool flag7 = unityCamera.farClipPlane < 300f || unityCamera.farClipPlane > 600f;
						if (flag7)
						{
							unityCamera.farClipPlane = XQualitySetting._CurrentSetting._CameraWorld;
						}
						unityCamera.cullingMask &= ~(XQualitySetting._QualityHighLayerOffset | XQualitySetting._QualityNormalLayerOffset);
						unityCamera.cullingMask |= XQualitySetting._CurrentSetting._CullMask;
						unityCamera.layerCullDistances = XQualitySetting._layerculldistance;
						unityCamera.cullingMask &= ~XQualitySetting._InvisiblityLayerOffset;
						unityCamera.cullingMask &= ~XQualitySetting._UILayerOffset;
					}
					bool flag8 = (int)Application.platform == 8 || XQualitySetting._IsPcOrSimulator;
					if (flag8)
					{
						XQualitySetting.fxPro = (unityCamera.GetComponent("FxPro") as IFxPro);
						bool flag9 = XQualitySetting.fxPro != null;
						if (flag9)
						{
							bool flag10 = XQualitySetting.GetQuality(EFun.EFxPro) || XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_LOGIN;
							if (flag10)
							{
								XQualitySetting.fxPro.Enable(true);
							}
							else
							{
								XQualitySetting.fxPro.Enable(false);
							}
						}
					}
					XSingleton<XFxMgr>.singleton.CameraLayerMask = (unityCamera.cullingMask | XQualitySetting._UILayerOffset);
					unityCamera.useOcclusionCulling = false;
				}
				bool flag11 = XQualitySetting._InHall && !XSingleton<XGame>.singleton.switchScene;
				if (flag11)
				{
					XQualitySetting.PostSceneLoad();
					XPlayer player = XSingleton<XEntityMgr>.singleton.Player;
					bool flag12 = player != null;
					if (flag12)
					{
						XShadowComponent xshadowComponent = player.GetXComponent(XShadowComponent.uuID) as XShadowComponent;
						bool flag13 = xshadowComponent != null;
						if (flag13)
						{
							xshadowComponent.ProcessShadow();
						}
					}
					List<XEntity> all = XSingleton<XEntityMgr>.singleton.GetAll();
					for (int j = 0; j < all.Count; j++)
					{
						XEntity xentity = all[j];
						bool flag14 = xentity.Equipment != null;
						if (flag14)
						{
							xentity.Equipment.RefreshSuitFx();
							xentity.Equipment.RefreshEquipFx();
							xentity.Equipment.RefreshSecondWeaponFx();
						}
						XShadowComponent xshadowComponent2 = xentity.GetXComponent(XShadowComponent.uuID) as XShadowComponent;
						bool flag15 = xshadowComponent2 != null;
						if (flag15)
						{
							xshadowComponent2.ProcessShadow();
						}
					}
				}
				RenderSettings.fog = XQualitySetting._CurrentSetting._EnableFog;
				Shader.globalMaximumLOD = XQualitySetting._CurrentSetting._ShaderLod;
				XFxMgr.MaxParticelCount = XQualitySetting._CurrentSetting._MaxParticelCount;
			}
		}

		public static void SetEnvSet(IEnvSetting envSet)
		{
			XQualitySetting._envSet = envSet;
		}

		public static void SetDofFade(float fade)
		{
			bool flag = XQualitySetting.fxPro != null;
			if (flag)
			{
				XQualitySetting.fxPro.SetDofFade(fade);
			}
		}

		public static void Update()
		{
			bool flag = XQualitySetting._CurrentSetting != null && XQualitySetting._CurrentSetting._ShaderLod >= 400 && XSingleton<XGame>.singleton.CurrentStage.Stage != EXStage.World;
			if (flag)
			{
				Shader.SetGlobalFloat("_windSpeed", Mathf.Sin(XQualitySetting._WindSpeedFactor * Time.realtimeSinceStartup));
			}
			Transform cameraTrans = XSingleton<XScene>.singleton.GameCamera.CameraTrans;
			bool flag2 = cameraTrans != null;
			if (flag2)
			{
				Shader.SetGlobalVector("cameraPos", cameraTrans.position);
			}
		}
	}
}