using System;
using UnityEngine;

namespace Artngame.SKYMASTER
{
	[ExecuteInEditMode]
	public class CloudHandlerSM : MonoBehaviour
	{
		public enum CloudPreset
		{
			Custom = 0,
			ClearDay = 1
		}

		public bool followPlayer;

		public bool rotateWithCamera;

		public bool rotateMultiQuadC;

		public float IntensityDiffOffset;

		public float IntensitySunOffset;

		public float IntensityFogOffset;

		[HideInInspector]
		public bool EnableInsideClouds;

		public bool FogFromSkyGrad;

		[HideInInspector]
		public bool LerpRot;

		public AnimationCurve IntensityDiff = new AnimationCurve(new Keyframe(0f, 0.4f), new Keyframe(0.374f, 0.292f), new Keyframe(0.6f, 0.2766f), new Keyframe(0.757f, 0.278f), new Keyframe(0.798f, 0.271f), new Keyframe(0.849f, 0.275f), new Keyframe(0.887f, 0.248f), new Keyframe(0.944f, 0.28f), new Keyframe(1f, 0.4f));

		public AnimationCurve IntensityFog = new AnimationCurve(new Keyframe(0f, 5f), new Keyframe(0.75f, 10f), new Keyframe(0.88f, 11f), new Keyframe(0.89f, 10.58f), new Keyframe(1f, 5f));

		public AnimationCurve IntensitySun = new AnimationCurve(new Keyframe(0f, 0.078f), new Keyframe(0.1864f, 0.148f), new Keyframe(0.71f, 0.129f), new Keyframe(0.839f, 0.303f), new Keyframe(0.9f, 0.13f), new Keyframe(1f, 0.078f));

		public bool CurvesFromSkyMaster;

		public bool DomeClouds = true;

		public Vector3 DomeScale;

		public Vector3 DomeHeights;

		public bool MultiQuadClouds;

		public Vector3 MultiQuadScale;

		public Vector3 MultiQuadHeights;

		public bool MultiQuadAClouds;

		public Vector3 MultiQuadAScale;

		public Vector3 MultiQuadAHeights;

		public bool MultiQuadBClouds;

		public Vector3 MultiQuadBScale;

		public Vector3 MultiQuadBHeights;

		public bool MultiQuadCClouds;

		public Vector3 MultiQuadCScale;

		public Vector3 MultiQuadCHeights;

		public bool OneQuadClouds;

		public Vector3 OneQuadScale;

		public Vector3 OneQuadHeights;

		public Transform FlatBedSPlane;

		public Transform SideSPlane;

		public Transform SideASPlane;

		public Transform SideBSPlane;

		public Transform SideCSPlane;

		public Transform RotCloudsSPlane;

		public bool WeatherDensity;

		public bool UseUnityFog;

		public float CloudEvolution = 0.07f;

		public float ClearDayCoverage = -0.12f;

		public float ClearDayHorizon = 0.1f;

		public float StormCoverage;

		public float StormHorizon = 0.01f;

		public Color StormSunColor = new Color(0.5f, 0.5f, 0.5f, 0.5f);

		public float Coverage = -0.12f;

		public float Transp = 0.51f;

		public float Intensity = 0.1f;

		public float Horizon = 0.1f;

		public CloudPreset cloudType = CloudPreset.ClearDay;

		public SkyMasterManager SkyManager;

		public bool autoRainbow;

		public float rainbowApperSpeed = 1f;

		private bool was_rain;

		private float was_rain_end_time;

		public float rainbowTime = 60f;

		public float rainboxMaxIntensity = 0.7f;

		public float rainboxMinIntensity;

		public Material rainbowMat;

		public Material cloudFlatMat;

		public Material cloudSidesMat;

		public Material cloudSidesAMat;

		public Material cloudSidesBMat;

		public Material cloudSidesCMat;

		public Material cloudRotMat;

		public Transform FlatBedClouds;

		public Transform SideClouds;

		public Transform SideAClouds;

		public Transform SideBClouds;

		public Transform SideCClouds;

		public Transform RotClouds;

		public GameObject LightningPrefab;

		public bool EnableLightning;

		public Color DayCloudColor = new Color(46f / 51f, 46f / 51f, 46f / 51f, 4f / 51f);

		public Color DayCloudShadowCol = new Color(0.23921569f, 0.23921569f, 27f / 85f, 14f / 51f);

		public Color DayCloudTintCol = new Color(0.043137256f, 0.043137256f, 0.043137256f, 1f);

		public Color DayCloudFogCol = new Color(0.76862746f, 73f / 85f, 78f / 85f, 1f);

		public float DayFogFactor = 1f;

		public float DayIntensity = 0.1f;

		public Color DawnCloudColor = new Color(77f / 85f, 38f / 51f, 0.9411765f, 22f / 51f);

		public Color DawnCloudShadowCol = new Color(14f / 51f, 1f / 85f, 1f / 85f, 0.40784314f);

		public Color DawnCloudTintCol = new Color(0.043137256f, 2f / 51f, 2f / 51f, 1f);

		public Color DawnCloudFogCol = new Color(82f / 85f, 0.07450981f, 0.05490196f, 0.88235295f);

		public float DawnFogFactor = 1.94f;

		public float DawnIntensity = -3.79f;

		public Color DuskCloudColor = new Color(0.12156863f, 0.11372549f, 0.11372549f, 0.14509805f);

		public Color DuskCloudShadowCol = new Color(0.6313726f, 0.32156864f, 13f / 85f, 21f / 85f);

		public Color DuskCloudTintCol = new Color(0.043137256f, 2f / 51f, 2f / 51f, 1f);

		public Color DuskCloudFogCol = new Color(82f / 85f, 0.07450981f, 0.05490196f, 0.88235295f);

		public float DuskFogFactor = 1.94f;

		public float DuskIntensity = -1.25f;

		public Color NightCloudColor = new Color(44f / 51f, 0.88235295f, 0.8235294f, 0.02745098f);

		private int prev_preset;

		public bool HasScatterShader;

		public bool UpdateScatterShader;

		public float fog_depth = 0.29f;

		public float reileigh = 1.3f;

		public float mieCoefficient = 1f;

		public float mieDirectionalG = 0.1f;

		public float ExposureBias = 0.11f;

		private const float n = 1.0003f;

		private const float N = 2.545E+25f;

		private const float pn = 0.035f;

		public Vector3 lambda = new Vector3(6.8E-07f, 5.5E-07f, 4.5E-07f);

		public Vector3 K = new Vector3(0.9f, 0.5f, 0.5f);

		public float WindStrength = 1f;

		public float WindParallaxFactor = 1.2f;

		public float CloudDensity = 0.0001f;

		public Transform LightningBox;

		private float last_lightning_time;

		public float lightning_every = 15f;

		public float max_lightning_time = 2f;

		public float lightning_rate_offset = 5f;

		private Transform LightningOne;

		private Transform LightningTwo;

		private void Start()
		{
			if (Application.isPlaying)
			{
				if (rainbowMat != null)
				{
					Color color = rainbowMat.GetColor("_Color");
					rainbowMat.SetColor("_Color", new Color(color.r, color.g, color.b, 0f));
				}
				_ = Camera.main != null;
				if (cloudFlatMat == null)
				{
					cloudFlatMat = FlatBedClouds.gameObject.GetComponentsInChildren<MeshRenderer>(includeInactive: true)[0].material;
				}
				if (cloudSidesMat == null)
				{
					cloudSidesMat = SideClouds.gameObject.GetComponentsInChildren<MeshRenderer>(includeInactive: true)[0].material;
				}
				if (cloudSidesAMat == null)
				{
					cloudSidesAMat = SideAClouds.gameObject.GetComponentsInChildren<MeshRenderer>(includeInactive: true)[0].material;
				}
				if (cloudSidesBMat == null)
				{
					cloudSidesBMat = SideBClouds.gameObject.GetComponentsInChildren<MeshRenderer>(includeInactive: true)[0].material;
				}
				if (cloudSidesCMat == null)
				{
					cloudSidesCMat = SideCClouds.gameObject.GetComponentsInChildren<MeshRenderer>(includeInactive: true)[0].material;
				}
				if (cloudRotMat == null)
				{
					cloudRotMat = RotClouds.gameObject.GetComponentsInChildren<MeshRenderer>(includeInactive: true)[0].material;
				}
				if (SkyManager != null)
				{
					if (cloudFlatMat != null)
					{
						UpdateCloudParams(Init: true, cloudFlatMat);
					}
					if (cloudSidesMat != null)
					{
						UpdateCloudParams(Init: true, cloudSidesMat);
					}
					if (cloudSidesAMat != null)
					{
						UpdateCloudParams(Init: true, cloudSidesAMat);
					}
					if (cloudSidesBMat != null)
					{
						UpdateCloudParams(Init: true, cloudSidesBMat);
					}
					if (cloudRotMat != null)
					{
						UpdateCloudParams(Init: true, cloudRotMat);
					}
				}
				if (WeatherDensity)
				{
					if (SkyManager.currentWeatherName == SkyMasterManager.Volume_Weather_types.HeavyStorm || SkyManager.currentWeatherName == SkyMasterManager.Volume_Weather_types.LightningStorm)
					{
						Coverage = StormCoverage;
						Horizon = StormHorizon;
						EnableLightning = true;
					}
					else
					{
						Coverage = ClearDayCoverage;
						Horizon = ClearDayHorizon;
						EnableLightning = false;
					}
				}
			}
			if (FlatBedClouds != null && cloudFlatMat != null)
			{
				DomeScale = FlatBedClouds.localScale;
				DomeHeights = new Vector3(FlatBedClouds.position.y, cloudFlatMat.GetFloat("_CutHeight"), 0f);
			}
			if (SideClouds != null && cloudSidesMat != null)
			{
				MultiQuadScale = SideClouds.localScale;
				MultiQuadHeights = new Vector3(SideClouds.position.y, cloudSidesMat.GetFloat("_CutHeight"), 0f);
			}
			if (SideAClouds != null && cloudSidesAMat != null)
			{
				MultiQuadAScale = SideAClouds.localScale;
				MultiQuadAHeights = new Vector3(SideAClouds.position.y, cloudSidesAMat.GetFloat("_CutHeight"), 0f);
			}
			if (SideBClouds != null && cloudSidesBMat != null)
			{
				MultiQuadBScale = SideBClouds.localScale;
				MultiQuadBHeights = new Vector3(SideBClouds.position.y, cloudSidesBMat.GetFloat("_CutHeight"), 0f);
			}
			if (SideCClouds != null && cloudSidesCMat != null)
			{
				MultiQuadCScale = SideCClouds.localScale;
				MultiQuadCHeights = new Vector3(SideCClouds.position.y, cloudSidesCMat.GetFloat("_CutHeight"), 0f);
			}
			if (RotClouds != null && cloudRotMat != null)
			{
				OneQuadScale = RotClouds.localScale;
				OneQuadHeights = new Vector3(RotClouds.position.y, cloudRotMat.GetFloat("_CutHeight"), 0f);
			}
		}

		private void UpdateCloudParams(bool Init, Material oceanMat)
		{
			bool flag = (SkyManager.AutoSunPosition && SkyManager.Rot_Sun_X > 0f) | (!SkyManager.AutoSunPosition && ((SkyManager.Current_Time > 9f + SkyManager.Shift_dawn) & (SkyManager.Current_Time <= SkyManager.NightTimeMax + SkyManager.Shift_dawn)));
			bool flag2 = (SkyManager.AutoSunPosition && SkyManager.Rot_Sun_X > 65f) | (!SkyManager.AutoSunPosition && SkyManager.Current_Time > 17f + SkyManager.Shift_dawn);
			bool flag3 = (SkyManager.AutoSunPosition && SkyManager.Rot_Sun_X > 85f) | (!SkyManager.AutoSunPosition && SkyManager.Current_Time > 22f + SkyManager.Shift_dawn);
			bool flag4 = (SkyManager.AutoSunPosition && SkyManager.Rot_Sun_X < 10f) | (!SkyManager.AutoSunPosition && SkyManager.Current_Time < 10f + SkyManager.Shift_dawn);
			float num = Time.deltaTime;
			if (Init)
			{
				num = 10000f;
			}
			if (SkyManager.windZone != null)
			{
				Vector4 vector = oceanMat.GetVector("_Velocity1");
				Vector4 vector2 = oceanMat.GetVector("_Velocity2");
				float windMain = SkyManager.windZone.windMain;
				Vector4 b = new Vector4(SkyManager.windZone.transform.forward.x, SkyManager.windZone.transform.forward.z, 0f, -0.007f) * (0f - windMain) * WindStrength * 1f;
				oceanMat.SetVector("_Velocity1", Vector4.Lerp(vector, b, 0.0001f * num * 21f));
				oceanMat.SetVector("_Velocity2", new Vector4(Mathf.Lerp(vector2.x, b.x * WindParallaxFactor * 1f, 0.0001f * num * 11f * WindParallaxFactor * 1f), Mathf.Lerp(vector2.y, b.y * WindParallaxFactor * 1f, 0.0001f * num * 11f * WindParallaxFactor), 0f, CloudEvolution));
			}
			if (!HasScatterShader)
			{
				return;
			}
			if (UpdateScatterShader)
			{
				reileigh = SkyManager.m_fRayleighScaleDepth;
				reileigh = SkyManager.m_Kr;
				mieCoefficient = SkyManager.m_Km;
			}
			if (!Application.isPlaying)
			{
				num = 10000f;
			}
			Color color = oceanMat.GetColor("_SunColor");
			Color color2 = oceanMat.GetColor("_ShadowColor");
			float a = oceanMat.GetFloat("_Density");
			oceanMat.SetFloat("_Density", Mathf.Lerp(a, CloudDensity, 0.27f * num + 0.05f));
			float a2 = oceanMat.GetFloat("_Coverage");
			float a3 = oceanMat.GetFloat("_Transparency");
			float a4 = oceanMat.GetFloat("_HorizonFactor");
			Color color3 = oceanMat.GetColor("_Color");
			Color color4 = oceanMat.GetColor("_FogColor");
			if (UseUnityFog)
			{
				oceanMat.SetFloat("_FogUnity", 1f);
			}
			else
			{
				oceanMat.SetFloat("_FogUnity", 0f);
			}
			float num2 = 0.3f * (SkyManager.SPEED + 0.1f);
			if (!Application.isPlaying)
			{
				num2 = 1000f * num2;
			}
			if (!SkyManager.VolCloudGradients)
			{
				float num3 = 0f;
				float num4 = 0f;
				if (!CurvesFromSkyMaster)
				{
					num3 = IntensityDiff.Evaluate(SkyManager.calcColorTime) + IntensityDiffOffset + 0.3f;
					num4 = IntensityFog.Evaluate(SkyManager.calcColorTime) + IntensityFogOffset;
				}
				else
				{
					num3 = SkyManager.VcloudLightDiff + IntensityDiffOffset + 0.3f;
					num4 = SkyManager.VcloudFog + IntensityFogOffset;
				}
				if (flag)
				{
					oceanMat.SetVector("sunPosition", -SkyManager.SunObj.transform.forward.normalized);
					if (flag2)
					{
						if (!flag3)
						{
							if (cloudType != CloudPreset.Custom && cloudType == CloudPreset.ClearDay)
							{
								oceanMat.SetColor("_SunColor", Color.Lerp(color, DuskCloudColor, 3f * num2 * num));
								oceanMat.SetColor("_ShadowColor", Color.Lerp(color2, DuskCloudShadowCol, num2 * num));
								oceanMat.SetFloat("_Coverage", Mathf.Lerp(a2, Coverage, num2 * num));
								oceanMat.SetFloat("_Transparency", Mathf.Lerp(a3, Transp, num2 * num));
								oceanMat.SetColor("_Color", Color.Lerp(color3, DuskCloudTintCol, num2 * num));
								oceanMat.SetColor("_FogColor", Color.Lerp(color4, DuskCloudFogCol, num2 * num));
							}
						}
						else if (cloudType != CloudPreset.Custom && cloudType == CloudPreset.ClearDay)
						{
							oceanMat.SetColor("_SunColor", Color.Lerp(color, DayCloudColor * 0.3f, 0.2f * num2 * num));
							oceanMat.SetColor("_ShadowColor", Color.Lerp(color2, 4f * DayCloudShadowCol, num2 * num));
							oceanMat.SetFloat("_Coverage", Mathf.Lerp(a2, Coverage, num2 * num));
							oceanMat.SetFloat("_Transparency", Mathf.Lerp(a3, Transp, num2 * num));
							oceanMat.SetColor("_Color", Color.Lerp(color3, DayCloudTintCol, num2 * num));
							oceanMat.SetColor("_FogColor", Color.Lerp(color4, DayCloudFogCol, 4f * num2 * num));
						}
					}
					else if (flag4)
					{
						if (cloudType != CloudPreset.Custom && cloudType == CloudPreset.ClearDay)
						{
							oceanMat.SetColor("_SunColor", Color.Lerp(color, DawnCloudColor, 1f * num2 * num));
							oceanMat.SetColor("_ShadowColor", Color.Lerp(color2, DawnCloudShadowCol, num2 * num));
							oceanMat.SetFloat("_Coverage", Mathf.Lerp(a2, Coverage, num2 * num));
							oceanMat.SetFloat("_Transparency", Mathf.Lerp(a3, Transp, num2 * num));
							oceanMat.SetColor("_Color", Color.Lerp(color3, DawnCloudTintCol, num2 * num));
							oceanMat.SetColor("_FogColor", Color.Lerp(color4, DawnCloudFogCol, num2 * num));
						}
					}
					else if (cloudType != CloudPreset.Custom && cloudType == CloudPreset.ClearDay)
					{
						oceanMat.SetColor("_SunColor", Color.Lerp(color, DayCloudColor, 0.3f * num2 * num));
						oceanMat.SetColor("_ShadowColor", Color.Lerp(color2, DayCloudShadowCol, num2 * num));
						oceanMat.SetFloat("_Coverage", Mathf.Lerp(a2, Coverage, num2 * num));
						oceanMat.SetFloat("_Transparency", Mathf.Lerp(a3, Transp, num2 * num));
						oceanMat.SetColor("_Color", Color.Lerp(color3, DayCloudTintCol, num2 * num));
						oceanMat.SetColor("_FogColor", Color.Lerp(color4, DayCloudFogCol, num2 * num));
					}
				}
				else
				{
					oceanMat.SetVector("sunPosition", -SkyManager.MoonObj.transform.forward.normalized);
					if (cloudType != CloudPreset.Custom && cloudType == CloudPreset.ClearDay)
					{
						oceanMat.SetColor("_SunColor", Color.Lerp(color, NightCloudColor, 0.8f * num2 * num));
						oceanMat.SetColor("_ShadowColor", Color.Lerp(color2, 1f * DayCloudShadowCol, num2 * num));
						oceanMat.SetFloat("_Coverage", Mathf.Lerp(a2, Coverage, num2 * num));
						oceanMat.SetFloat("_Transparency", Mathf.Lerp(a3, Transp, num2 * num));
						oceanMat.SetColor("_Color", Color.Lerp(color3, DayCloudTintCol, num2 * num));
						oceanMat.SetColor("_FogColor", Color.Lerp(color4, DayCloudFogCol, 4f * num2 * num));
					}
				}
				oceanMat.SetFloat("_ColorDiff", num3);
				oceanMat.SetFloat("_HorizonFactor", Mathf.Lerp(a4, Horizon, num2 * num + 0.05f));
				oceanMat.SetFloat("_FogFactor", num4);
			}
			oceanMat.SetVector("betaR", totalRayleigh(lambda) * reileigh);
			oceanMat.SetVector("betaM", totalMie(lambda, K, fog_depth) * mieCoefficient);
			oceanMat.SetFloat("fog_depth", fog_depth);
			oceanMat.SetFloat("mieCoefficient", mieCoefficient);
			oceanMat.SetFloat("mieDirectionalG", mieDirectionalG);
			oceanMat.SetFloat("ExposureBias", ExposureBias);
			float num5 = 0.002f;
			if (!Application.isPlaying)
			{
				num5 = 0.1f;
			}
			if (SkyManager.VolCloudGradients)
			{
				if (flag)
				{
					oceanMat.SetVector("sunPosition", -SkyManager.SunObj.transform.forward.normalized);
				}
				else
				{
					oceanMat.SetVector("sunPosition", -SkyManager.MoonObj.transform.forward.normalized);
				}
				oceanMat.SetFloat("_Transparency", Mathf.Lerp(a3, Transp, num2 * num));
				oceanMat.SetFloat("_HorizonFactor", Mathf.Lerp(a4, Horizon, num2 * num + 0.05f));
				float num6 = 0f;
				float num7 = 0f;
				float num8 = 0f;
				if (!CurvesFromSkyMaster)
				{
					num6 = IntensitySun.Evaluate(SkyManager.calcColorTime) + IntensitySunOffset;
					num7 = IntensityDiff.Evaluate(SkyManager.calcColorTime) + IntensityDiffOffset;
					num8 = IntensityFog.Evaluate(SkyManager.calcColorTime) + IntensityFogOffset;
				}
				else
				{
					num6 = SkyManager.VcloudSunIntensity + IntensitySunOffset;
					num7 = SkyManager.VcloudLightDiff + IntensityDiffOffset;
					num8 = SkyManager.VcloudFog + IntensityFogOffset;
				}
				if (WeatherDensity && Application.isPlaying)
				{
					if (SkyManager.currentWeatherName == SkyMasterManager.Volume_Weather_types.HeavyStorm)
					{
						oceanMat.SetColor("_SunColor", Color.Lerp(color, new Color(StormSunColor.r, StormSunColor.g, StormSunColor.b, num6), 0.8f * num2 * num + num5));
					}
					else
					{
						oceanMat.SetColor("_SunColor", Color.Lerp(color, new Color(SkyManager.gradCloudLitColor.r, SkyManager.gradCloudLitColor.g, SkyManager.gradCloudLitColor.b, num6), 0.8f * num2 * num + num5));
					}
				}
				else
				{
					oceanMat.SetColor("_SunColor", Color.Lerp(color, new Color(SkyManager.gradCloudLitColor.r, SkyManager.gradCloudLitColor.g, SkyManager.gradCloudLitColor.b, num6), 0.8f * num2 * num + num5));
				}
				oceanMat.SetColor("_ShadowColor", Color.Lerp(color2, new Color(SkyManager.gradCloudShadeColor.r, SkyManager.gradCloudShadeColor.g, SkyManager.gradCloudShadeColor.b, SkyManager.VolCloudTransp), 0.8f * num2 * num + num5));
				oceanMat.SetFloat("_ColorDiff", num7);
				if (FogFromSkyGrad)
				{
					oceanMat.SetColor("_FogColor", Color.Lerp(color4, SkyManager.gradSkyColor, 4f * num2 * num + num5));
				}
				else
				{
					oceanMat.SetColor("_FogColor", Color.Lerp(color4, SkyManager.gradCloudFogColor, 4f * num2 * num + num5));
				}
				oceanMat.SetFloat("_FogFactor", num8);
				oceanMat.SetFloat("_Coverage", Mathf.Lerp(a2, Coverage, num2 * num + num5));
			}
			if (WeatherDensity)
			{
				if (SkyManager.currentWeatherName == SkyMasterManager.Volume_Weather_types.HeavyStorm || SkyManager.currentWeatherName == SkyMasterManager.Volume_Weather_types.LightningStorm)
				{
					Coverage = Mathf.Lerp(Coverage, StormCoverage, num + 0.05f);
					Horizon = Mathf.Lerp(Horizon, StormHorizon, num + 0.05f);
					EnableLightning = true;
				}
				else
				{
					Coverage = Mathf.Lerp(Coverage, ClearDayCoverage, 0.8f * num2 * num + num5);
					Horizon = Mathf.Lerp(Horizon, ClearDayHorizon, num + 0.05f);
					EnableLightning = false;
				}
			}
		}

		private void Update()
		{
			if (MultiQuadClouds)
			{
				if (!SideClouds.gameObject.activeInHierarchy)
				{
					SideClouds.gameObject.SetActive(value: true);
				}
				if (SideClouds != null && cloudSidesMat != null)
				{
					SideClouds.localScale = MultiQuadScale;
					SideClouds.position = new Vector3(SideClouds.position.x, MultiQuadHeights.x, SideClouds.position.z);
					cloudSidesMat.SetFloat("_CutHeight", MultiQuadHeights.y);
				}
			}
			else if (SideClouds.gameObject.activeInHierarchy)
			{
				SideClouds.gameObject.SetActive(value: false);
			}
			if (MultiQuadAClouds)
			{
				if (!SideAClouds.gameObject.activeInHierarchy)
				{
					SideAClouds.gameObject.SetActive(value: true);
				}
				if (SideAClouds != null && cloudSidesAMat != null)
				{
					SideAClouds.localScale = MultiQuadAScale;
					SideAClouds.position = new Vector3(SideAClouds.position.x, MultiQuadAHeights.x, SideAClouds.position.z);
					cloudSidesAMat.SetFloat("_CutHeight", MultiQuadAHeights.y);
				}
			}
			else if (SideAClouds.gameObject.activeInHierarchy)
			{
				SideAClouds.gameObject.SetActive(value: false);
			}
			if (MultiQuadBClouds)
			{
				if (!SideBClouds.gameObject.activeInHierarchy)
				{
					SideBClouds.gameObject.SetActive(value: true);
				}
				if (SideBClouds != null && cloudSidesBMat != null)
				{
					SideBClouds.localScale = MultiQuadBScale;
					SideBClouds.position = new Vector3(SideBClouds.position.x, MultiQuadBHeights.x, SideBClouds.position.z);
					cloudSidesBMat.SetFloat("_CutHeight", MultiQuadBHeights.y);
				}
			}
			else if (SideBClouds.gameObject.activeInHierarchy)
			{
				SideBClouds.gameObject.SetActive(value: false);
			}
			if (MultiQuadCClouds)
			{
				if (!SideCClouds.gameObject.activeInHierarchy)
				{
					SideCClouds.gameObject.SetActive(value: true);
				}
				if (SideCClouds != null && cloudSidesCMat != null)
				{
					SideCClouds.localScale = MultiQuadCScale;
					SideCClouds.position = new Vector3(SideCClouds.position.x, MultiQuadCHeights.x, SideCClouds.position.z);
					cloudSidesCMat.SetFloat("_CutHeight", MultiQuadCHeights.y);
				}
			}
			else if (SideCClouds.gameObject.activeInHierarchy)
			{
				SideCClouds.gameObject.SetActive(value: false);
			}
			if (OneQuadClouds)
			{
				if (!RotClouds.gameObject.activeInHierarchy)
				{
					RotClouds.gameObject.SetActive(value: true);
				}
				if (RotClouds != null && cloudRotMat != null)
				{
					RotClouds.localScale = OneQuadScale;
					RotClouds.position = new Vector3(RotClouds.position.x, OneQuadHeights.x, RotClouds.position.z);
					cloudRotMat.SetFloat("_CutHeight", OneQuadHeights.y);
				}
			}
			else if (RotClouds.gameObject.activeInHierarchy)
			{
				RotClouds.gameObject.SetActive(value: false);
			}
			if (DomeClouds)
			{
				if (!FlatBedClouds.gameObject.activeInHierarchy)
				{
					FlatBedClouds.gameObject.SetActive(value: true);
				}
				if (FlatBedClouds != null && cloudFlatMat != null)
				{
					FlatBedClouds.localScale = DomeScale;
					FlatBedClouds.position = new Vector3(FlatBedClouds.position.x, DomeHeights.x, FlatBedClouds.position.z);
					cloudFlatMat.SetFloat("_CutHeight", DomeHeights.y);
				}
			}
			else if (FlatBedClouds.gameObject.activeInHierarchy)
			{
				FlatBedClouds.gameObject.SetActive(value: false);
			}
			if (SkyManager != null)
			{
				if (cloudFlatMat != null && DomeClouds)
				{
					UpdateCloudParams(Init: false, cloudFlatMat);
				}
				if (cloudSidesMat != null && (bool)SideClouds)
				{
					UpdateCloudParams(Init: false, cloudSidesMat);
				}
				if (cloudSidesAMat != null && (bool)SideAClouds)
				{
					UpdateCloudParams(Init: false, cloudSidesAMat);
				}
				if (cloudSidesBMat != null && (bool)SideBClouds)
				{
					UpdateCloudParams(Init: false, cloudSidesBMat);
				}
				if (cloudSidesCMat != null && (bool)SideCClouds)
				{
					UpdateCloudParams(Init: false, cloudSidesCMat);
				}
				if (cloudRotMat != null && OneQuadClouds)
				{
					UpdateCloudParams(Init: false, cloudRotMat);
				}
			}
			if (rainbowMat != null)
			{
				Color color = rainbowMat.GetColor("_Color");
				if (!Application.isPlaying)
				{
					float a = rainboxMaxIntensity;
					if (autoRainbow)
					{
						if (SkyManager.currentWeatherName == SkyMasterManager.Volume_Weather_types.Rain || SkyManager.currentWeatherName == SkyMasterManager.Volume_Weather_types.HeavyStorm || SkyManager.currentWeatherName == SkyMasterManager.Volume_Weather_types.HeavyStormDark)
						{
							a = ((SkyManager.currentWeatherName != SkyMasterManager.Volume_Weather_types.Rain) ? (rainboxMaxIntensity / 3f) : (rainboxMaxIntensity / 1f));
						}
						if (SkyManager.currentWeatherName == SkyMasterManager.Volume_Weather_types.Cloudy)
						{
							a = rainboxMinIntensity;
						}
					}
					rainbowMat.SetColor("_Color", new Color(color.r, color.g, color.b, a));
				}
				else
				{
					float num = rainboxMaxIntensity;
					if (autoRainbow)
					{
						if (SkyManager.currentWeatherName == SkyMasterManager.Volume_Weather_types.Rain || SkyManager.currentWeatherName == SkyMasterManager.Volume_Weather_types.HeavyStorm || (SkyManager.currentWeatherName == SkyMasterManager.Volume_Weather_types.HeavyStormDark && !was_rain))
						{
							was_rain = true;
							was_rain_end_time = Time.fixedTime;
							num = ((SkyManager.currentWeatherName != SkyMasterManager.Volume_Weather_types.Rain) ? (rainboxMaxIntensity / 3f) : (rainboxMaxIntensity / 1f));
						}
						if (SkyManager.currentWeatherName == SkyMasterManager.Volume_Weather_types.Cloudy)
						{
							if (was_rain)
							{
								float num2 = Time.fixedTime - was_rain_end_time;
								if (num2 > rainbowTime)
								{
									num = rainboxMaxIntensity / num2;
									if (num2 < 0.05f || num2 <= 0f)
									{
										was_rain = false;
									}
								}
								else
								{
									num = rainbowTime * rainboxMaxIntensity / num2;
								}
							}
							else
							{
								num = 0f;
							}
							if (num > rainboxMaxIntensity)
							{
								num = rainboxMaxIntensity;
							}
						}
					}
					rainbowMat.SetColor("_Color", Color.Lerp(color, new Color(color.r, color.g, color.b, num), Time.deltaTime * 0.001f * rainbowApperSpeed + 0.002f));
				}
			}
			if (!Application.isPlaying)
			{
				return;
			}
			if (EnableLightning)
			{
				if (LightningOne == null)
				{
					LightningOne = UnityEngine.Object.Instantiate(LightningPrefab).transform;
					LightningOne.gameObject.SetActive(value: false);
				}
				if (LightningTwo == null)
				{
					LightningTwo = UnityEngine.Object.Instantiate(LightningPrefab).transform;
					LightningTwo.gameObject.SetActive(value: false);
				}
				if (LightningBox != null)
				{
					if (Time.fixedTime - last_lightning_time > lightning_every - UnityEngine.Random.Range(0f - lightning_rate_offset, lightning_rate_offset))
					{
						Vector2 vector = LightningBox.position.x * Vector2.one + LightningBox.localScale.x / 2f * new Vector2(-1f, 1f);
						Vector2 vector2 = LightningBox.position.y * Vector2.one + LightningBox.localScale.y / 2f * new Vector2(-1f, 1f);
						Vector2 vector3 = LightningBox.position.z * Vector2.one + LightningBox.localScale.z / 2f * new Vector2(-1f, 1f);
						LightningOne.position = new Vector3(UnityEngine.Random.Range(vector.x, vector.y), UnityEngine.Random.Range(vector2.x, vector2.y), UnityEngine.Random.Range(vector3.x, vector3.y));
						if (UnityEngine.Random.Range(0f, SkyManager.WeatherSeverity + 1f) != 1f)
						{
							LightningOne.gameObject.SetActive(value: true);
						}
						LightningTwo.position = new Vector3(UnityEngine.Random.Range(vector.x, vector.y), UnityEngine.Random.Range(vector2.x, vector2.y), UnityEngine.Random.Range(vector3.x, vector3.y));
						if (UnityEngine.Random.Range(0f, SkyManager.WeatherSeverity + 1f) != 1f)
						{
							LightningTwo.gameObject.SetActive(value: true);
						}
						last_lightning_time = Time.fixedTime;
					}
					else if (Time.fixedTime - last_lightning_time > max_lightning_time)
					{
						if (LightningOne != null && LightningOne.gameObject.activeInHierarchy)
						{
							LightningOne.gameObject.SetActive(value: false);
						}
						if (LightningTwo != null && LightningTwo.gameObject.activeInHierarchy)
						{
							LightningTwo.gameObject.SetActive(value: false);
						}
					}
				}
			}
			else
			{
				if (LightningOne != null && LightningOne.gameObject.activeInHierarchy)
				{
					LightningOne.gameObject.SetActive(value: false);
				}
				if (LightningTwo != null && LightningTwo.gameObject.activeInHierarchy)
				{
					LightningTwo.gameObject.SetActive(value: false);
				}
			}
			if (rotateWithCamera && Camera.main != null)
			{
				if (RotClouds != null && RotClouds.gameObject.activeInHierarchy)
				{
					if (!EnableInsideClouds)
					{
						if (RotCloudsSPlane != null && Application.isPlaying)
						{
							RotCloudsSPlane.parent = null;
							if (!RotCloudsSPlane.gameObject.activeInHierarchy)
							{
								RotCloudsSPlane.gameObject.SetActive(value: true);
							}
						}
						if (LerpRot)
						{
							RotClouds.eulerAngles = new Vector3(RotClouds.eulerAngles.x, Mathf.Lerp(RotClouds.eulerAngles.y, Camera.main.transform.eulerAngles.y, Time.deltaTime * 20f), RotClouds.eulerAngles.z);
						}
						else
						{
							RotClouds.eulerAngles = new Vector3(RotClouds.eulerAngles.x, Camera.main.transform.eulerAngles.y, RotClouds.eulerAngles.z);
						}
					}
					else
					{
						float num3 = 0f;
						Transform transform = Camera.main.transform;
						float num4 = transform.position.y - 100f;
						if (num4 > 0f)
						{
							num3 = num4 / 10f - transform.eulerAngles.x;
							Debug.Log(num3);
						}
						RotClouds.eulerAngles = new Vector3(num3, transform.eulerAngles.y, RotClouds.eulerAngles.z);
					}
				}
				else if (RotCloudsSPlane != null && RotCloudsSPlane.gameObject.activeInHierarchy)
				{
					RotCloudsSPlane.gameObject.SetActive(value: false);
				}
				if (SideClouds != null && SideClouds.gameObject.activeInHierarchy)
				{
					if (!EnableInsideClouds)
					{
						if (SideSPlane != null && Application.isPlaying)
						{
							SideSPlane.parent = null;
							if (!SideSPlane.gameObject.activeInHierarchy)
							{
								SideSPlane.gameObject.SetActive(value: true);
							}
						}
						if (LerpRot)
						{
							SideClouds.eulerAngles = new Vector3(SideClouds.eulerAngles.x, Mathf.Lerp(SideClouds.eulerAngles.y, Camera.main.transform.eulerAngles.y, Time.deltaTime * 20f), SideClouds.eulerAngles.z);
						}
						else
						{
							SideClouds.eulerAngles = new Vector3(SideClouds.eulerAngles.x, Camera.main.transform.eulerAngles.y, SideClouds.eulerAngles.z);
						}
					}
				}
				else if (SideSPlane != null && SideSPlane.gameObject.activeInHierarchy)
				{
					SideSPlane.gameObject.SetActive(value: false);
				}
				if (rotateMultiQuadC && SideCClouds != null && SideCClouds.gameObject.activeInHierarchy)
				{
					if (!EnableInsideClouds)
					{
						if (SideCSPlane != null && Application.isPlaying)
						{
							SideCSPlane.parent = null;
							if (!SideCSPlane.gameObject.activeInHierarchy)
							{
								SideCSPlane.gameObject.SetActive(value: true);
							}
						}
						if (LerpRot)
						{
							SideCClouds.eulerAngles = new Vector3(SideCClouds.eulerAngles.x, Mathf.Lerp(SideCClouds.eulerAngles.y, Camera.main.transform.eulerAngles.y, Time.deltaTime * 20f), SideCClouds.eulerAngles.z);
						}
						else
						{
							SideCClouds.eulerAngles = new Vector3(SideCClouds.eulerAngles.x, Camera.main.transform.eulerAngles.y, SideCClouds.eulerAngles.z);
						}
					}
				}
				else if (SideCSPlane != null && SideCSPlane.gameObject.activeInHierarchy)
				{
					SideCSPlane.gameObject.SetActive(value: false);
				}
			}
			if (followPlayer && SkyManager.Hero != null)
			{
				SideClouds.position = new Vector3(SkyManager.Hero.position.x, SideClouds.position.y, SkyManager.Hero.position.z);
				SideAClouds.position = new Vector3(SkyManager.Hero.position.x, SideAClouds.position.y, SkyManager.Hero.position.z);
				SideBClouds.position = new Vector3(SkyManager.Hero.position.x, SideBClouds.position.y, SkyManager.Hero.position.z);
				SideCClouds.position = new Vector3(SkyManager.Hero.position.x, SideCClouds.position.y, SkyManager.Hero.position.z);
				FlatBedClouds.position = new Vector3(SkyManager.Hero.position.x, FlatBedClouds.position.y, SkyManager.Hero.position.z);
				RotClouds.position = new Vector3(SkyManager.Hero.position.x, RotClouds.position.y, SkyManager.Hero.position.z);
				if (SideSPlane != null)
				{
					SideSPlane.position = new Vector3(SkyManager.Hero.position.x, SideSPlane.position.y, SkyManager.Hero.position.z);
				}
				if (SideCSPlane != null)
				{
					SideCSPlane.position = new Vector3(SkyManager.Hero.position.x, SideCSPlane.position.y, SkyManager.Hero.position.z);
				}
				if (RotCloudsSPlane != null)
				{
					RotCloudsSPlane.position = new Vector3(SkyManager.Hero.position.x, RotCloudsSPlane.position.y, SkyManager.Hero.position.z);
				}
			}
		}

		private static Vector3 totalRayleigh(Vector3 lambda)
		{
			return new Vector3(8f * Mathf.Pow(MathF.PI, 3f) * Mathf.Pow(Mathf.Pow(1.0003f, 2f) - 1f, 2f) * 6.105f / (7.635E+25f * Mathf.Pow(lambda.x, 4f) * 5.755f), 8f * Mathf.Pow(MathF.PI, 3f) * Mathf.Pow(Mathf.Pow(1.0003f, 2f) - 1f, 2f) * 6.105f / (7.635E+25f * Mathf.Pow(lambda.y, 4f) * 5.755f), 8f * Mathf.Pow(MathF.PI, 3f) * Mathf.Pow(Mathf.Pow(1.0003f, 2f) - 1f, 2f) * 6.105f / (7.635E+25f * Mathf.Pow(lambda.z, 4f) * 5.755f));
		}

		private static Vector3 totalMie(Vector3 lambda, Vector3 K, float T)
		{
			float num = 0.2f * T * 1E-16f;
			return new Vector3(0.434f * num * MathF.PI * Mathf.Pow(MathF.PI * 2f / lambda.x, 2f) * K.x, 0.434f * num * MathF.PI * Mathf.Pow(MathF.PI * 2f / lambda.y, 2f) * K.y, 0.434f * num * MathF.PI * Mathf.Pow(MathF.PI * 2f / lambda.z, 2f) * K.z);
		}
	}
}