using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering;

[ExecuteInEditMode]
[AddComponentMenu("Enviro/Sky System")]
public class EnviroSky : MonoBehaviour
{
	public delegate void HourPassed();

	public delegate void DayPassed();

	public delegate void YearPassed();

	public delegate void WeatherChanged(EnviroWeatherPrefab weatherType);

	public delegate void ZoneWeatherChanged(EnviroWeatherPrefab weatherType, EnviroZone zone);

	public delegate void SeasonChanged(SeasonVariables.Seasons season);

	public delegate void isNightE();

	public delegate void isDay();

	private static EnviroSky _instance;

	[Tooltip("Assign your player gameObject here. Required Field! or enable AssignInRuntime!")]
	public GameObject Player;

	[Tooltip("Assign your main camera here. Required Field! or enable AssignInRuntime!")]
	public Camera PlayerCamera;

	[Tooltip("If enabled Enviro will search for your Player and Camera by Tag!")]
	public bool AssignInRuntime;

	[Tooltip("Your Player Tag")]
	public string PlayerTag = string.Empty;

	[Tooltip("Your CameraTag")]
	public string CameraTag = "MainCamera";

	public EnviroPositioning Position;

	public ObjectVariables Components;

	public AudioVariables Audio;

	public TimeVariables GameTime;

	public LightVariables Lighting;

	public Sky Sky;

	public EnviroWeather Weather;

	public SeasonVariables Seasons;

	public CloudVariables Clouds;

	public FogSettings Fog;

	public LightShaftsSettings LightShafts;

	public SatellitesVariables Satellites;

	public EnviroQualitySettings Quality;

	[HideInInspector]
	public List<Transform> mySatellites = new List<Transform>();

	[HideInInspector]
	public bool started;

	private bool isNight = true;

	[HideInInspector]
	public EnviroFog atmosphericFog;

	[HideInInspector]
	public EnviroLightShafts lightShaftsScript;

	[HideInInspector]
	public GameObject EffectsHolder;

	[HideInInspector]
	public AudioSource AudioSourceWeather;

	[HideInInspector]
	public AudioSource AudioSourceWeather2;

	[HideInInspector]
	public AudioSource AudioSourceAmbient;

	[HideInInspector]
	public AudioSource AudioSourceThunder;

	[HideInInspector]
	public List<EnviroVegetationInstance> EnviroVegetationInstances = new List<EnviroVegetationInstance>();

	[HideInInspector]
	public float currentHour;

	[HideInInspector]
	public float currentDay;

	[HideInInspector]
	public float currentYear;

	[HideInInspector]
	public float currentTimeInHours;

	private Transform DomeTransform;

	private Material VolumeCloudShader1;

	private Material VolumeCloudShadowShader1;

	private Material VolumeCloudShader2;

	private Material VolumeCloudShadowShader2;

	private Transform SunTransform;

	private Light SunLight;

	private Transform MoonTransform;

	private Renderer MoonRenderer;

	private Material MoonShader;

	private Light MoonLight;

	private float lastHourUpdate;

	private float starsRot;

	private float lastHour;

	private const float pi = (float)Math.PI;

	private Vector3 K = new Vector3(686f, 678f, 666f);

	private const float n = 1.0003f;

	private const float N = 2.545E+25f;

	private const float pn = 0.035f;

	public static EnviroSky instance
	{
		get
		{
			if (_instance == null)
			{
				_instance = UnityEngine.Object.FindObjectOfType<EnviroSky>();
			}
			return _instance;
		}
	}

	private float OrbitRadius
	{
		get
		{
			return DomeTransform.localScale.x;
		}
	}

	public event HourPassed OnHourPassed;

	public event DayPassed OnDayPassed;

	public event YearPassed OnYearPassed;

	public event WeatherChanged OnWeatherChanged;

	public event ZoneWeatherChanged OnZoneWeatherChanged;

	public event SeasonChanged OnSeasonChanged;

	public event isNightE OnNightTime;

	public event isDay OnDayTime;

	private void Start()
	{
		started = false;
		lastHourUpdate = GameTime.Hours;
		currentTimeInHours = GetInHours(GameTime.Hours, GameTime.Days, GameTime.Years);
		RemoveSatellites();
		CreateSatellites();
		lastHourUpdate = currentTimeInHours;
		Weather.currentActiveWeatherID = Weather.zones[0].zoneWeatherPrefabs[0].GetComponent<EnviroWeatherPrefab>();
		Weather.lastActiveWeatherID = Weather.zones[0].zoneWeatherPrefabs[0].GetComponent<EnviroWeatherPrefab>();
		Weather.nextUpdate = currentTimeInHours + 1f;
		Weather.currentAudioSource = AudioSourceWeather;
		InvokeRepeating("UpdateEnviroment", 0f, Quality.UpdateInterval);
		if (PlayerCamera != null && Player != null && !AssignInRuntime)
		{
			Init();
			CreateEffects();
			started = true;
		}
	}

	private void OnEnable()
	{
		DomeTransform = base.transform;
		if (AssignInRuntime)
		{
			started = false;
		}
		else if (PlayerCamera != null && Player != null)
		{
			Init();
			CreateEffects();
			started = true;
		}
	}

	private void Init()
	{
		atmosphericFog = PlayerCamera.gameObject.GetComponent<EnviroFog>();
		if (atmosphericFog == null)
		{
			atmosphericFog = PlayerCamera.gameObject.AddComponent<EnviroFog>();
			atmosphericFog.fogMaterial = Fog.fogMaterial;
			atmosphericFog.fogShader = Fog.fogMaterial.shader;
		}
		lightShaftsScript = PlayerCamera.gameObject.GetComponent<EnviroLightShafts>();
		if (lightShaftsScript == null)
		{
			lightShaftsScript = PlayerCamera.gameObject.AddComponent<EnviroLightShafts>();
			lightShaftsScript.sunShaftsMaterial = LightShafts.lightShaftsMaterial;
			lightShaftsScript.sunShaftsShader = LightShafts.lightShaftsMaterial.shader;
			lightShaftsScript.simpleClearMaterial = LightShafts.clearMaterial;
			lightShaftsScript.simpleClearShader = LightShafts.clearMaterial.shader;
		}
		RemoveSatellites();
		CreateSatellites();
		RenderSettings.fogMode = Fog.Fogmode;
		RenderSettings.skybox = Components.sky;
		RenderSettings.ambientMode = Lighting.ambientMode;
		if (PlayerCamera != null)
		{
			PlayerCamera.clearFlags = CameraClearFlags.Skybox;
		}
		InitClouds();
		if ((bool)Components.Sun)
		{
			SunTransform = Components.Sun.transform;
			SunLight = Components.Sun.GetComponent<Light>();
		}
		else
		{
			Debug.LogError("Please set Sun object in inspector!");
		}
		if ((bool)Components.Moon)
		{
			MoonTransform = Components.Moon.transform;
			MoonRenderer = Components.Moon.GetComponent<Renderer>();
			MoonShader = MoonRenderer.sharedMaterial;
			MoonLight = Components.Moon.GetComponent<Light>();
		}
		else
		{
			Debug.LogError("Please set Moon object in inspector!");
		}
	}

	public void AssignAndStart(GameObject player, Camera Camera)
	{
		Player = player;
		PlayerCamera = Camera;
		Init();
		CreateEffects();
		started = true;
	}

	public void ChangeFocus(GameObject player, Camera Camera)
	{
		Player = player;
		PlayerCamera = Camera;
		atmosphericFog = PlayerCamera.gameObject.GetComponent<EnviroFog>();
		if (atmosphericFog == null)
		{
			atmosphericFog = PlayerCamera.gameObject.AddComponent<EnviroFog>();
			atmosphericFog.fogMaterial = Fog.fogMaterial;
			atmosphericFog.fogShader = Fog.fogMaterial.shader;
		}
		lightShaftsScript = PlayerCamera.gameObject.GetComponent<EnviroLightShafts>();
		if (lightShaftsScript == null)
		{
			lightShaftsScript = PlayerCamera.gameObject.AddComponent<EnviroLightShafts>();
			lightShaftsScript.sunShaftsMaterial = LightShafts.lightShaftsMaterial;
			lightShaftsScript.sunShaftsShader = LightShafts.lightShaftsMaterial.shader;
			lightShaftsScript.simpleClearMaterial = LightShafts.clearMaterial;
			lightShaftsScript.simpleClearShader = LightShafts.clearMaterial.shader;
		}
	}

	public void InitClouds()
	{
		if ((bool)Components.VolumeCloudsLayer1 && (bool)Components.VolumeCloudsLayer2)
		{
			VolumeCloudShader1 = Components.VolumeCloudsLayer1.GetComponent<Renderer>().sharedMaterial;
			VolumeCloudShader2 = Components.VolumeCloudsLayer2.GetComponent<Renderer>().sharedMaterial;
			MeshFilter component = Components.VolumeCloudsLayer1.GetComponent<MeshFilter>();
			MeshFilter component2 = Components.VolumeCloudsLayer2.GetComponent<MeshFilter>();
			if (component != null && component.sharedMesh != null)
			{
				UnityEngine.Object.DestroyImmediate(component.sharedMesh);
			}
			if (component2 != null && component2.sharedMesh != null)
			{
				UnityEngine.Object.DestroyImmediate(component2.sharedMesh);
			}
			CreateVolumeCloudMesh(Clouds.Quality);
			CreateVolumeCloudMesh(1);
		}
		else if (Components.VolumeCloudsLayer1 == null)
		{
			Debug.LogError("Please set VolumeCloudsLayer1 object in inspector!");
		}
		if ((bool)Components.VolumeCloudsShadowsLayer1)
		{
			VolumeCloudShadowShader1 = Components.VolumeCloudsShadowsLayer1.GetComponent<Renderer>().sharedMaterial;
		}
		else if (Components.VolumeCloudsShadowsLayer1 == null)
		{
			Debug.LogError("Please set VolumeCloudsShadowsLayer1 object in inspector!");
		}
		if ((bool)Components.VolumeCloudsShadowsLayer2)
		{
			VolumeCloudShadowShader2 = Components.VolumeCloudsShadowsLayer2.GetComponent<Renderer>().sharedMaterial;
		}
		else if (Components.VolumeCloudsShadowsLayer2 == null)
		{
			Debug.LogError("Please set VolumeCloudsShadowsLayer2 object in inspector!");
		}
	}

	public virtual void NotifyHourPassed()
	{
		if (this.OnHourPassed != null)
		{
			this.OnHourPassed();
		}
	}

	public virtual void NotifyDayPassed()
	{
		if (this.OnDayPassed != null)
		{
			this.OnDayPassed();
		}
	}

	public virtual void NotifyYearPassed()
	{
		if (this.OnYearPassed != null)
		{
			this.OnYearPassed();
		}
	}

	public virtual void NotifyWeatherChanged(EnviroWeatherPrefab type)
	{
		if (this.OnWeatherChanged != null)
		{
			this.OnWeatherChanged(type);
		}
	}

	public virtual void NotifyZoneWeatherChanged(EnviroWeatherPrefab type, EnviroZone zone)
	{
		if (this.OnZoneWeatherChanged != null)
		{
			this.OnZoneWeatherChanged(type, zone);
		}
	}

	public virtual void NotifySeasonChanged(SeasonVariables.Seasons season)
	{
		if (this.OnSeasonChanged != null)
		{
			this.OnSeasonChanged(season);
		}
	}

	public virtual void NotifyIsNight()
	{
		if (this.OnNightTime != null)
		{
			this.OnNightTime();
		}
	}

	public virtual void NotifyIsDay()
	{
		if (this.OnDayTime != null)
		{
			this.OnDayTime();
		}
	}

	public void CreateEffects()
	{
		if (!(EffectsHolder == null))
		{
			return;
		}
		EffectsHolder = new GameObject();
		EffectsHolder.name = "Enviro Effects";
		EffectsHolder.transform.position = Player.transform.position;
		CreateWeatherEffectHolder();
		GameObject gameObject = UnityEngine.Object.Instantiate(Audio.SFXHolderPrefab, Vector3.zero, Quaternion.identity);
		gameObject.transform.parent = EffectsHolder.transform;
		EnviroAudioSource[] componentsInChildren = gameObject.GetComponentsInChildren<EnviroAudioSource>();
		for (int i = 0; i < componentsInChildren.Length; i++)
		{
			switch (componentsInChildren[i].myFunction)
			{
			case EnviroAudioSource.AudioSourceFunction.Weather1:
				AudioSourceWeather = componentsInChildren[i].audiosrc;
				break;
			case EnviroAudioSource.AudioSourceFunction.Weather2:
				AudioSourceWeather2 = componentsInChildren[i].audiosrc;
				break;
			case EnviroAudioSource.AudioSourceFunction.Ambient:
				AudioSourceAmbient = componentsInChildren[i].audiosrc;
				break;
			case EnviroAudioSource.AudioSourceFunction.Thunder:
				AudioSourceThunder = componentsInChildren[i].audiosrc;
				break;
			}
		}
	}

	public int RegisterMe(EnviroVegetationInstance me)
	{
		EnviroVegetationInstances.Add(me);
		return EnviroVegetationInstances.Count - 1;
	}

	public void ChangeSeason(SeasonVariables.Seasons season)
	{
		Seasons.currentSeasons = season;
		NotifySeasonChanged(season);
	}

	private void UpdateSeason()
	{
		if (currentDay >= 0f && currentDay < Seasons.SpringInDays)
		{
			Seasons.currentSeasons = SeasonVariables.Seasons.Spring;
			if (Seasons.lastSeason != Seasons.currentSeasons)
			{
				NotifySeasonChanged(SeasonVariables.Seasons.Spring);
			}
			Seasons.lastSeason = Seasons.currentSeasons;
		}
		else if (currentDay >= Seasons.SpringInDays && currentDay < Seasons.SpringInDays + Seasons.SummerInDays)
		{
			Seasons.currentSeasons = SeasonVariables.Seasons.Summer;
			if (Seasons.lastSeason != Seasons.currentSeasons)
			{
				NotifySeasonChanged(SeasonVariables.Seasons.Summer);
			}
			Seasons.lastSeason = Seasons.currentSeasons;
		}
		else if (currentDay >= Seasons.SpringInDays + Seasons.SummerInDays && currentDay < Seasons.SpringInDays + Seasons.SummerInDays + Seasons.AutumnInDays)
		{
			Seasons.currentSeasons = SeasonVariables.Seasons.Autumn;
			if (Seasons.lastSeason != Seasons.currentSeasons)
			{
				NotifySeasonChanged(SeasonVariables.Seasons.Autumn);
			}
			Seasons.lastSeason = Seasons.currentSeasons;
		}
		else if (currentDay >= Seasons.SpringInDays + Seasons.SummerInDays + Seasons.AutumnInDays && currentDay <= Seasons.SpringInDays + Seasons.SummerInDays + Seasons.AutumnInDays + Seasons.WinterInDays)
		{
			Seasons.currentSeasons = SeasonVariables.Seasons.Winter;
			if (Seasons.lastSeason != Seasons.currentSeasons)
			{
				NotifySeasonChanged(SeasonVariables.Seasons.Winter);
			}
			Seasons.lastSeason = Seasons.currentSeasons;
		}
	}

	public float GetInHours(float hours, float days, float years)
	{
		return hours + days * 24f + years * (Seasons.SpringInDays + Seasons.SummerInDays + Seasons.AutumnInDays + Seasons.WinterInDays) * 24f;
	}

	private void UpdateEnviroment()
	{
		if (Seasons.calcSeasons)
		{
			UpdateSeason();
		}
		if (EnviroVegetationInstances.Count <= 0)
		{
			return;
		}
		for (int i = 0; i < EnviroVegetationInstances.Count; i++)
		{
			if (EnviroVegetationInstances[i] != null)
			{
				EnviroVegetationInstances[i].UpdateInstance();
			}
		}
	}

	private void CreateSatellites()
	{
		for (int i = 0; i < Satellites.additionalSatellites.Count; i++)
		{
			GameObject gameObject = UnityEngine.Object.Instantiate(Satellites.additionalSatellites[i].prefab, base.transform.position + new Vector3(0f, Satellites.additionalSatellites[i].orbit, 0f), Quaternion.identity);
			gameObject.transform.parent = base.transform;
			mySatellites.Add(gameObject.transform);
		}
	}

	private void RemoveSatellites()
	{
		for (int i = 0; i < mySatellites.Count; i++)
		{
			UnityEngine.Object.DestroyImmediate(mySatellites[i].gameObject);
		}
		mySatellites = new List<Transform>();
	}

	private void UpdateQuality()
	{
		switch (Quality.CloudsQuality)
		{
		case EnviroQualitySettings.CloudQuality.None:
			Components.VolumeCloudsLayer1.SetActive(false);
			Components.VolumeCloudsLayer2.SetActive(false);
			Components.VolumeCloudsShadowsLayer1.SetActive(false);
			Components.VolumeCloudsShadowsLayer2.SetActive(false);
			break;
		case EnviroQualitySettings.CloudQuality.OneLayer:
			Components.VolumeCloudsLayer1.SetActive(true);
			Components.VolumeCloudsLayer2.SetActive(false);
			if (Quality.CloudsShadowCast)
			{
				Components.VolumeCloudsShadowsLayer1.SetActive(true);
				Components.VolumeCloudsShadowsLayer2.SetActive(false);
			}
			else
			{
				Components.VolumeCloudsShadowsLayer1.SetActive(false);
				Components.VolumeCloudsShadowsLayer2.SetActive(false);
			}
			break;
		case EnviroQualitySettings.CloudQuality.TwoLayer:
			Components.VolumeCloudsLayer1.SetActive(true);
			Components.VolumeCloudsLayer2.SetActive(true);
			if (Quality.CloudsShadowCast)
			{
				Components.VolumeCloudsShadowsLayer1.SetActive(true);
				Components.VolumeCloudsShadowsLayer2.SetActive(true);
			}
			else
			{
				Components.VolumeCloudsShadowsLayer1.SetActive(false);
				Components.VolumeCloudsShadowsLayer2.SetActive(false);
			}
			break;
		}
		if (atmosphericFog != null)
		{
			atmosphericFog.distanceFog = Fog.distanceFog;
			atmosphericFog.heightFog = Fog.heightFog;
			atmosphericFog.height = Fog.height;
			atmosphericFog.heightDensity = Fog.heightDensity;
			atmosphericFog.useRadialDistance = Fog.useRadialDistance;
			atmosphericFog.startDistance = Fog.startDistance;
			if (Fog.AdvancedFog)
			{
				atmosphericFog.enabled = true;
			}
			else
			{
				atmosphericFog.enabled = false;
			}
		}
		if (lightShaftsScript != null)
		{
			lightShaftsScript.resolution = LightShafts.resolution;
			lightShaftsScript.screenBlendMode = LightShafts.screenBlendMode;
			lightShaftsScript.useDepthTexture = LightShafts.useDepthTexture;
			lightShaftsScript.sunThreshold = LightShafts.thresholdColor.Evaluate(GameTime.Hours / 24f);
			lightShaftsScript.sunShaftBlurRadius = LightShafts.blurRadius;
			lightShaftsScript.sunShaftIntensity = LightShafts.intensity;
			lightShaftsScript.maxRadius = LightShafts.maxRadius;
			lightShaftsScript.sunColor = LightShafts.lighShaftsColor.Evaluate(GameTime.Hours / 24f);
			if (LightShafts.lightShafts)
			{
				lightShaftsScript.enabled = true;
			}
			else
			{
				lightShaftsScript.enabled = false;
			}
		}
	}

	private Vector3 CalculatePosition()
	{
		Vector3 result = default(Vector3);
		result.x = Player.transform.position.x;
		result.z = Player.transform.position.z;
		result.y = Position.fixedSkyHeight;
		return result;
	}

	private void UpdateSatellites()
	{
		for (int i = 0; i < mySatellites.Count; i++)
		{
			float angle = (currentTimeInHours - lastHour) * Satellites.additionalSatellites[i].speed;
			mySatellites[i].RotateAround(base.transform.position, Satellites.additionalSatellites[i].coords, angle);
			Vector3 b = (mySatellites[i].position - base.transform.position).normalized * Satellites.additionalSatellites[i].orbit + base.transform.position;
			mySatellites[i].position = Vector3.Slerp(mySatellites[i].position, b, Time.deltaTime * 5f);
		}
		lastHour = currentTimeInHours;
	}

	private void Update()
	{
		if (!started)
		{
			if (!AssignInRuntime || !(PlayerTag != string.Empty) || !(CameraTag != string.Empty) || !Application.isPlaying)
			{
				started = false;
				return;
			}
			Player = GameObject.FindGameObjectWithTag(PlayerTag);
			PlayerCamera = GameObject.FindGameObjectWithTag(CameraTag).GetComponent<Camera>();
			if (!(Player != null) || !(PlayerCamera != null))
			{
				started = false;
				return;
			}
			Init();
			CreateEffects();
			started = true;
		}
		UpdateTime();
		ValidateParameters();
		UpdateQuality();
		UpdateAmbientLight();
		UpdateWeather();
		if (EffectsHolder != null)
		{
			EffectsHolder.transform.position = Player.transform.position;
		}
		if (Fog.AdvancedFog)
		{
			UpdateAdvancedFog();
		}
		float f = (float)Math.PI / 180f * GameTime.Latitude;
		float num = Mathf.Sin(f);
		float num2 = Mathf.Cos(f);
		float num3 = (float)Math.PI / 180f * GameTime.Longitude;
		float f2 = 0.4093f * Mathf.Sin((float)Math.PI / 184f * (GameTime.Days - 81f));
		float num4 = Mathf.Sin(f2);
		float num5 = Mathf.Cos(f2);
		float num6 = (int)(GameTime.Longitude / 15f);
		float num7 = (float)Math.PI / 12f * num6;
		float num8 = GameTime.Hours + 0.17f * Mathf.Sin(0.03369f * (GameTime.Days - 80f)) - 0.129f * Mathf.Sin((float)Math.PI * 2f / 355f * (GameTime.Days - 8f)) + 12f / (float)Math.PI * (num7 - num3);
		float f3 = (float)Math.PI / 12f * num8;
		float num9 = Mathf.Sin(f3);
		float num10 = Mathf.Cos(f3);
		float f4 = num * num4 - num2 * num5 * num10;
		float num11 = Mathf.Asin(f4);
		float y = (0f - num5) * num9;
		float x = num2 * num4 - num * num5 * num10;
		float num12 = Mathf.Atan2(y, x);
		float num13 = (float)Math.PI / 2f - num11;
		float phi = num12;
		SunTransform.position = DomeTransform.position + DomeTransform.rotation * SphericalToCartesian(OrbitRadius, num13, phi);
		SunTransform.LookAt(DomeTransform.position);
		MoonTransform.position = DomeTransform.position + DomeTransform.rotation * SphericalToCartesian(OrbitRadius, num13 + (float)Math.PI, phi);
		MoonTransform.LookAt(DomeTransform.position);
		if (isNight)
		{
			Sky.currentStarsIntensity = Mathf.Lerp(Sky.currentStarsIntensity, Sky.StarsIntensity, Time.deltaTime * 20f);
		}
		else
		{
			Sky.currentStarsIntensity = Mathf.Lerp(Sky.currentStarsIntensity, 0f, Time.deltaTime * 20f);
		}
		SetupSunAndMoonColor(num13);
		SetupShader(num13);
		if (PlayerCamera != null)
		{
			if (!Position.FixedHeight)
			{
				base.transform.position = PlayerCamera.transform.position;
			}
			else
			{
				base.transform.position = CalculatePosition();
			}
			base.transform.localScale = new Vector3(PlayerCamera.farClipPlane - PlayerCamera.farClipPlane * 0.1f, PlayerCamera.farClipPlane - PlayerCamera.farClipPlane * 0.1f, PlayerCamera.farClipPlane - PlayerCamera.farClipPlane * 0.1f);
		}
		if (!isNight && (GameTime.Hours >= GameTime.NightTimeInHours || GameTime.Hours <= GameTime.MorningTimeInHours) && AudioSourceAmbient != null)
		{
			switch (Seasons.currentSeasons)
			{
			case SeasonVariables.Seasons.Spring:
				AudioSourceAmbient.clip = Audio.SpringNightAmbient;
				break;
			case SeasonVariables.Seasons.Summer:
				AudioSourceAmbient.clip = Audio.SummerNightAmbient;
				break;
			case SeasonVariables.Seasons.Autumn:
				AudioSourceAmbient.clip = Audio.AutumnNightAmbient;
				break;
			case SeasonVariables.Seasons.Winter:
				AudioSourceAmbient.clip = Audio.WinterNightAmbient;
				break;
			}
			AudioSourceAmbient.loop = true;
			AudioSourceAmbient.Play();
			isNight = true;
			NotifyIsNight();
		}
		else if (isNight && GameTime.Hours <= GameTime.NightTimeInHours && GameTime.Hours >= GameTime.MorningTimeInHours && AudioSourceAmbient != null)
		{
			switch (Seasons.currentSeasons)
			{
			case SeasonVariables.Seasons.Spring:
				AudioSourceAmbient.clip = Audio.SpringDayAmbient;
				break;
			case SeasonVariables.Seasons.Summer:
				AudioSourceAmbient.clip = Audio.SummerDayAmbient;
				break;
			case SeasonVariables.Seasons.Autumn:
				AudioSourceAmbient.clip = Audio.AutumnDayAmbient;
				break;
			case SeasonVariables.Seasons.Winter:
				AudioSourceAmbient.clip = Audio.WinterDayAmbient;
				break;
			}
			AudioSourceAmbient.loop = true;
			AudioSourceAmbient.Play();
			isNight = false;
			NotifyIsDay();
		}
	}

	private Vector3 BetaRay()
	{
		Vector3 vector = Sky.waveLenght * 1E-09f;
		Vector3 result = default(Vector3);
		result.x = 8f * Mathf.Pow((float)Math.PI, 3f) * Mathf.Pow(Mathf.Pow(1.0003f, 2f) - 1f, 2f) * 6.105f / (7.635E+25f * Mathf.Pow(vector.x, 4f) * 5.755f) * 2000f;
		result.y = 8f * Mathf.Pow((float)Math.PI, 3f) * Mathf.Pow(Mathf.Pow(1.0003f, 2f) - 1f, 2f) * 6.105f / (7.635E+25f * Mathf.Pow(vector.y, 4f) * 5.755f) * 2000f;
		result.z = 8f * Mathf.Pow((float)Math.PI, 3f) * Mathf.Pow(Mathf.Pow(1.0003f, 2f) - 1f, 2f) * 6.105f / (7.635E+25f * Mathf.Pow(vector.z, 4f) * 5.755f) * 2000f;
		return result;
	}

	private Vector3 BetaMie()
	{
		float num = 0.2f * Sky.turbidity * 10f;
		Vector3 result = default(Vector3);
		result.x = 434f * num * (float)Math.PI * Mathf.Pow((float)Math.PI * 2f / Sky.waveLenght.x, 2f) * K.x;
		result.y = 434f * num * (float)Math.PI * Mathf.Pow((float)Math.PI * 2f / Sky.waveLenght.y, 2f) * K.y;
		result.z = 434f * num * (float)Math.PI * Mathf.Pow((float)Math.PI * 2f / Sky.waveLenght.z, 2f) * K.z;
		result.x = Mathf.Pow(result.x, -1f);
		result.y = Mathf.Pow(result.y, -1f);
		result.z = Mathf.Pow(result.z, -1f);
		return result;
	}

	private Vector3 GetMieG()
	{
		return new Vector3(1f - Sky.g * Sky.g, 1f + Sky.g * Sky.g, 2f * Sky.g);
	}

	private void SetupShader(float setup)
	{
		RenderSettings.skybox.SetVector("_SunDir", -SunLight.transform.forward);
		RenderSettings.skybox.SetMatrix("_Sun", SunTransform.worldToLocalMatrix);
		RenderSettings.skybox.SetColor("_scatteringColor", Sky.scatteringColor.Evaluate(GameTime.Hours / 24f));
		RenderSettings.skybox.SetColor("_sunDiskColor", Sky.SunDiskColor.Evaluate(GameTime.Hours / 24f));
		RenderSettings.skybox.SetColor("_weatherColor", Sky.weatherMod);
		RenderSettings.skybox.SetVector("_waveLenght", Sky.waveLenght);
		RenderSettings.skybox.SetVector("_Bm", BetaMie() * Sky.mie);
		RenderSettings.skybox.SetVector("_Br", BetaRay() * Sky.rayleigh);
		RenderSettings.skybox.SetVector("_mieG", GetMieG());
		RenderSettings.skybox.SetFloat("_SunIntensity", Sky.SunIntensity);
		RenderSettings.skybox.SetFloat("_SunDiskSize", Sky.SunDiskScale);
		RenderSettings.skybox.SetFloat("_SunDiskIntensity", Sky.SunDiskIntensity);
		RenderSettings.skybox.SetFloat("_SunDiskSize", Sky.SunDiskScale);
		RenderSettings.skybox.SetFloat("_Exposure", Sky.SkyExposure);
		RenderSettings.skybox.SetFloat("_SkyLuminance", Sky.SkyLuminence);
		RenderSettings.skybox.SetFloat("_scatteringPower", Sky.scatteringCurve.Evaluate(GameTime.Hours / 24f));
		RenderSettings.skybox.SetFloat("_SkyCorrection", Sky.SkyCorrection);
		RenderSettings.skybox.SetFloat("_StarsIntensity", Sky.currentStarsIntensity);
		if (Sky.StarsBlinking > 0f)
		{
			starsRot += Sky.StarsBlinking * Time.deltaTime;
			Quaternion q = Quaternion.Euler(starsRot, starsRot, starsRot);
			Matrix4x4 value = Matrix4x4.TRS(Vector3.zero, q, new Vector3(1f, 1f, 1f));
			RenderSettings.skybox.SetMatrix("_NoiseMatrix", value);
		}
		if (VolumeCloudShader1 != null && Quality.CloudsQuality == EnviroQualitySettings.CloudQuality.OneLayer)
		{
			VolumeCloudShader1.SetFloat("_Scale", PlayerCamera.farClipPlane * Clouds.Scaling);
			VolumeCloudShader1.SetColor("_BaseColor", Clouds.FirstColor);
			VolumeCloudShader1.SetColor("_ShadingColor", Clouds.SecondColor);
			VolumeCloudShader1.SetFloat("_CloudCover", Clouds.Coverage);
			VolumeCloudShader1.SetFloat("_Density", Clouds.Density);
			VolumeCloudShader1.SetFloat("_CloudAlpha", Clouds.Alpha);
			VolumeCloudShader1.SetFloat("_Speed1Layer", Clouds.Speed1);
			VolumeCloudShader1.SetFloat("_Speed2Layer", Clouds.Speed2);
			VolumeCloudShader1.SetVector("_WindDir", Clouds.WindDir);
			VolumeCloudShader1.SetFloat("_Exposure", Sky.SkyExposure);
			VolumeCloudShader1.SetFloat("_ambient", Clouds.AmbientLightIntensity);
			VolumeCloudShader1.SetFloat("_direct", Clouds.DirectLightIntensity);
			VolumeCloudShader1.SetFloat("_nightColorMod", Clouds.DirectLightIntensityTimed.Evaluate(GameTime.Hours / 24f));
		}
		if (VolumeCloudShader1 != null && VolumeCloudShader2 != null && Quality.CloudsQuality == EnviroQualitySettings.CloudQuality.TwoLayer)
		{
			VolumeCloudShader1.SetFloat("_Scale", PlayerCamera.farClipPlane * Clouds.Scaling);
			VolumeCloudShader1.SetColor("_BaseColor", Clouds.FirstColor);
			VolumeCloudShader1.SetColor("_ShadingColor", Clouds.SecondColor);
			VolumeCloudShader1.SetFloat("_CloudCover", Clouds.Coverage);
			VolumeCloudShader1.SetFloat("_Density", Clouds.Density);
			VolumeCloudShader1.SetFloat("_CloudAlpha", Clouds.Alpha);
			VolumeCloudShader1.SetFloat("_Speed1Layer", Clouds.Speed1);
			VolumeCloudShader1.SetFloat("_Speed2Layer", Clouds.Speed2);
			VolumeCloudShader1.SetVector("_WindDir", Clouds.WindDir);
			VolumeCloudShader1.SetFloat("_direct", Clouds.DirectLightIntensity);
			VolumeCloudShader1.SetFloat("_ambient", Clouds.AmbientLightIntensity);
			VolumeCloudShader1.SetFloat("_nightColorMod", Clouds.DirectLightIntensityTimed.Evaluate(GameTime.Hours / 24f));
			VolumeCloudShader2.SetFloat("_Scale", PlayerCamera.farClipPlane * Clouds.Scaling);
			VolumeCloudShader2.SetColor("_BaseColor", Clouds.FirstColor);
			VolumeCloudShader2.SetColor("_ShadingColor", Clouds.SecondColor);
			VolumeCloudShader2.SetFloat("_CloudCover", Clouds.Coverage);
			VolumeCloudShader2.SetFloat("_Density", Clouds.Density);
			VolumeCloudShader2.SetFloat("_CloudAlpha", Clouds.Alpha);
			VolumeCloudShader2.SetFloat("_Speed1Layer", Clouds.Speed1);
			VolumeCloudShader2.SetFloat("_Speed2Layer", Clouds.Speed2);
			VolumeCloudShader2.SetVector("_WindDir", Clouds.WindDir);
			VolumeCloudShader2.SetFloat("_Offset", Clouds.LayerOffset);
			VolumeCloudShader2.SetFloat("_direct", Clouds.DirectLightIntensity);
			VolumeCloudShader2.SetFloat("_ambient", Clouds.AmbientLightIntensity);
			VolumeCloudShader2.SetFloat("_nightColorMod", Clouds.DirectLightIntensityTimed.Evaluate(GameTime.Hours / 24f));
		}
		if (VolumeCloudShadowShader1 != null && Quality.CloudsShadowCast && Quality.CloudsQuality == EnviroQualitySettings.CloudQuality.OneLayer)
		{
			VolumeCloudShadowShader1.SetFloat("_Scale", PlayerCamera.farClipPlane * Clouds.Scaling);
			VolumeCloudShadowShader1.SetFloat("_CloudCover", Clouds.Coverage);
			VolumeCloudShadowShader1.SetFloat("_CloudAlpha", Clouds.Alpha);
			VolumeCloudShadowShader1.SetFloat("_Speed1Layer", Clouds.Speed1);
			VolumeCloudShadowShader1.SetFloat("_Speed2Layer", Clouds.Speed2);
			VolumeCloudShadowShader1.SetVector("_WindDir", Clouds.WindDir);
		}
		if (VolumeCloudShadowShader2 != null && Quality.CloudsShadowCast && Quality.CloudsQuality == EnviroQualitySettings.CloudQuality.TwoLayer)
		{
			VolumeCloudShadowShader1.SetFloat("_Scale", PlayerCamera.farClipPlane * Clouds.Scaling);
			VolumeCloudShadowShader1.SetFloat("_CloudCover", Clouds.Coverage);
			VolumeCloudShadowShader1.SetFloat("_CloudAlpha", Clouds.Alpha);
			VolumeCloudShadowShader1.SetFloat("_Speed1Layer", Clouds.Speed1);
			VolumeCloudShadowShader1.SetFloat("_Speed2Layer", Clouds.Speed2);
			VolumeCloudShadowShader1.SetVector("_WindDir", Clouds.WindDir);
			VolumeCloudShadowShader2.SetFloat("_Scale", PlayerCamera.farClipPlane * Clouds.Scaling);
			VolumeCloudShadowShader2.SetFloat("_CloudCover", Clouds.Coverage);
			VolumeCloudShadowShader2.SetFloat("_CloudAlpha", Clouds.Alpha);
			VolumeCloudShadowShader2.SetFloat("_Speed1Layer", Clouds.Speed1);
			VolumeCloudShadowShader2.SetFloat("_Speed2Layer", Clouds.Speed2);
			VolumeCloudShadowShader2.SetVector("_WindDir", Clouds.WindDir);
			VolumeCloudShadowShader2.SetFloat("_Offset", Clouds.LayerOffset);
		}
		if (MoonShader != null)
		{
			MoonShader.SetFloat("_Phase", Lighting.MoonPhase);
		}
	}

	private void UpdateAdvancedFog()
	{
		Fog.fogMaterial.SetVector("_SunDir", -SunLight.transform.forward);
		Fog.fogMaterial.SetMatrix("_SunMatrix", SunTransform.worldToLocalMatrix);
		Fog.fogMaterial.SetColor("_scatteringColor", Sky.scatteringColor.Evaluate(GameTime.Hours / 24f));
		Fog.fogMaterial.SetColor("_sunDiskColor", Sky.SunDiskColor.Evaluate(GameTime.Hours / 24f));
		Fog.fogMaterial.SetColor("_weatherColor", Sky.weatherMod);
		Fog.fogMaterial.SetVector("_waveLenght", Sky.waveLenght);
		Fog.fogMaterial.SetVector("_Bm", BetaMie() * Sky.mie);
		Fog.fogMaterial.SetVector("_Br", BetaRay() * Sky.rayleigh);
		Fog.fogMaterial.SetVector("_mieG", GetMieG());
		Fog.fogMaterial.SetFloat("_SunIntensity", Sky.SunIntensity);
		Fog.fogMaterial.SetFloat("_SunDiskSize", Sky.SunDiskScale);
		Fog.fogMaterial.SetFloat("_SunDiskIntensity", Sky.SunDiskIntensity);
		Fog.fogMaterial.SetFloat("_SunDiskSize", Sky.SunDiskScale);
		Fog.fogMaterial.SetFloat("_Exposure", Sky.SkyExposure);
		Fog.fogMaterial.SetFloat("_SkyLuminance", Sky.SkyLuminence);
		Fog.fogMaterial.SetFloat("_scatteringPower", Sky.scatteringCurve.Evaluate(GameTime.Hours / 24f));
		Fog.fogMaterial.SetFloat("_SkyCorrection", Sky.SkyCorrection);
		Fog.fogMaterial.SetFloat("_SkyFogHeight", Fog.skyFogHeight);
		Fog.fogMaterial.SetFloat("_SkyFogStrenght", Fog.skyFogStrength);
		Fog.fogMaterial.SetFloat("_scatteringStrenght", Fog.scatteringStrenght);
		Fog.fogMaterial.SetFloat("_distanceFogIntensity", Fog.distanceFogIntensity);
		Fog.fogMaterial.SetVector("_NoiseData", new Vector4(Fog.noiseScale, Fog.heightDensity, Fog.noiseIntensity, 0f));
		Fog.fogMaterial.SetVector("_NoiseVelocity", new Vector4(Fog.heightFogVelocity.x, Fog.heightFogVelocity.y, 0f, 0f));
	}

	private void FixedUpdate()
	{
		if (started)
		{
			UpdateSatellites();
		}
	}

	private void UpdateTime()
	{
		float num = GameTime.DayLengthInMinutes * 60f;
		float num2 = num / 24f;
		float num3 = Time.deltaTime / num2;
		float num4 = Time.deltaTime / (30f * num) * 2f;
		if (GameTime.ProgressTime)
		{
			GameTime.Hours += num3;
			Lighting.MoonPhase += num4;
			if (Lighting.MoonPhase < -1f)
			{
				Lighting.MoonPhase += 2f;
			}
			else if (Lighting.MoonPhase > 1f)
			{
				Lighting.MoonPhase -= 2f;
			}
			if (GameTime.Hours >= lastHourUpdate + 1f)
			{
				lastHourUpdate = GameTime.Hours;
				NotifyHourPassed();
			}
			if (GameTime.Hours >= 24f)
			{
				GameTime.Hours = 0f;
				NotifyHourPassed();
				lastHourUpdate = 0f;
				GameTime.Days += 1f;
				NotifyDayPassed();
			}
			if (GameTime.Days >= Seasons.SpringInDays + Seasons.SummerInDays + Seasons.AutumnInDays + Seasons.WinterInDays)
			{
				GameTime.Years += 1f;
				GameTime.Days = 0f;
				NotifyYearPassed();
			}
			currentHour = GameTime.Hours;
			currentDay = GameTime.Days;
			currentYear = GameTime.Years;
			currentTimeInHours = GetInHours(currentHour, currentDay, currentYear);
		}
	}

	private void UpdateAmbientLight()
	{
		RenderSettings.ambientIntensity = Lighting.ambientIntensity.Evaluate(GameTime.Hours / 24f);
		switch (Lighting.ambientMode)
		{
		case AmbientMode.Flat:
			RenderSettings.ambientSkyColor = Lighting.ambientSkyColor.Evaluate(GameTime.Hours / 24f);
			break;
		case AmbientMode.Trilight:
			RenderSettings.ambientSkyColor = Lighting.ambientSkyColor.Evaluate(GameTime.Hours / 24f);
			RenderSettings.ambientEquatorColor = Lighting.ambientEquatorColor.Evaluate(GameTime.Hours / 24f);
			RenderSettings.ambientGroundColor = Lighting.ambientGroundColor.Evaluate(GameTime.Hours / 24f);
			break;
		case AmbientMode.Skybox:
			DynamicGI.UpdateEnvironment();
			break;
		}
	}

	private void SetupSunAndMoonColor(float setup)
	{
		SunLight.color = Lighting.LightColor.Evaluate(GameTime.Hours / 24f);
		MoonLight.color = Lighting.LightColor.Evaluate(GameTime.Hours / 24f);
		Shader.SetGlobalColor("_EnviroLighting", Lighting.LightColor.Evaluate(GameTime.Hours / 24f));
		float num = (float)Math.PI / 2f - setup;
		float num2 = Mathf.Abs(num);
		float num3 = 0.17453292f;
		float b = Lighting.SunIntensity + Lighting.SunWeatherMod;
		float num4 = Lighting.MoonIntensity * Mathf.Clamp01(1.3f - Mathf.Abs(Lighting.MoonPhase)) + Lighting.SunWeatherMod;
		if (num4 <= 0.1f)
		{
			num4 = 0.1f;
		}
		if (num > 0f)
		{
			MoonLight.enabled = false;
			SunLight.enabled = true;
			if (num2 < num3)
			{
				SunLight.intensity = Mathf.Lerp(0.3f, b, num2 / num3);
			}
			else
			{
				SunLight.intensity = Mathf.Lerp(SunLight.intensity, b, 0.01f);
			}
			if (lightShaftsScript != null && LightShafts.lightShafts)
			{
				lightShaftsScript.sunTransform = Components.Sun.transform;
			}
		}
		else
		{
			SunLight.enabled = false;
			MoonLight.enabled = true;
			if (num2 < num3)
			{
				MoonLight.intensity = Mathf.Lerp(0.3f, num4, num2 / num3);
			}
			else
			{
				MoonLight.intensity = Mathf.Lerp(MoonLight.intensity, num4, 0.01f);
			}
		}
		RenderSettings.fogColor = SunLight.color * Sky.weatherMod;
	}

	private void ValidateParameters()
	{
		GameTime.Hours = Mathf.Repeat(GameTime.Hours, 24f);
		GameTime.Longitude = Mathf.Clamp(GameTime.Longitude, -180f, 180f);
		GameTime.Latitude = Mathf.Clamp(GameTime.Latitude, -90f, 90f);
	}

	private Vector3 SphericalToCartesian(float radius, float theta, float phi)
	{
		float num = Mathf.Sin(theta);
		float num2 = Mathf.Cos(theta);
		float num3 = Mathf.Sin(phi);
		float num4 = Mathf.Cos(phi);
		Vector3 result = default(Vector3);
		result.x = radius * num * num4;
		result.y = radius * num2;
		result.z = radius * num * num3;
		return result;
	}

	private void CreateVolumeCloudMesh(int slices)
	{
		Vector3[] array = new Vector3[Clouds.segmentCount * Clouds.segmentCount * slices];
		Vector2[] array2 = new Vector2[array.Length];
		int[] array3 = new int[(Clouds.segmentCount - 1) * (Clouds.segmentCount - 1) * slices * 2 * 3];
		Color[] array4 = new Color[array.Length];
		float num = 1f / ((float)Clouds.segmentCount - 1f);
		Vector3 vector = new Vector3(num * 2f, 1f / (float)Mathf.Clamp(slices - 1, 1, 999999) * Clouds.thickness, num * 2f);
		float num2 = num;
		int num3 = 0;
		int num4 = 0;
		int num5 = 0;
		float f = 0f;
		float num6 = -1f;
		float num7 = 0f;
		for (int i = 0; i < slices; i++)
		{
			num6 = -1f + (float)i * (2f / (float)slices);
			num7 = ((!((float)i < (float)slices * 0.5f)) ? (2f - 1f / ((float)slices * 0.5f) * (float)(i + 1)) : (1f / ((float)slices * 0.5f) * (float)i));
			if (slices == 1)
			{
				num7 = 1f;
			}
			for (int j = 0; j < Clouds.segmentCount; j++)
			{
				int num8 = Clouds.segmentCount * num3;
				for (int k = 0; k < Clouds.segmentCount; k++)
				{
					if (Clouds.curved)
					{
						f = Vector3.Distance(new Vector3(vector.x * (float)k - 1f, 0f, vector.z * (float)j - 1f), Vector3.zero);
					}
					if (slices == 1)
					{
						array[k + num8] = new Vector3(vector.x * (float)k - 1f, Mathf.Pow(f, 2f) * Clouds.curvedIntensity, vector.z * (float)j - 1f);
					}
					else
					{
						array[k + num8] = new Vector3(vector.x * (float)k - 1f, vector.y * (float)i - Clouds.thickness / 2f + Mathf.Pow(f, 2f) * Clouds.curvedIntensity, vector.z * (float)j - 1f);
					}
					array2[k + num8] = new Vector2(num2 * (float)k, num2 * (float)j);
					array4[k + num8] = new Vector4(num6, num6, num6, num7);
				}
				num3++;
				if (j >= 1)
				{
					for (int l = 0; l < Clouds.segmentCount - 1; l++)
					{
						array3[num5] = l + num4 + i * Clouds.segmentCount;
						array3[1 + num5] = Clouds.segmentCount + l + num4 + i * Clouds.segmentCount;
						array3[2 + num5] = 1 + l + num4 + i * Clouds.segmentCount;
						array3[3 + num5] = Clouds.segmentCount + 1 + l + num4 + i * Clouds.segmentCount;
						array3[4 + num5] = 1 + l + num4 + i * Clouds.segmentCount;
						array3[5 + num5] = Clouds.segmentCount + l + num4 + i * Clouds.segmentCount;
						num5 += 6;
					}
					num4 += Clouds.segmentCount;
				}
			}
		}
		if (slices > 1)
		{
			Mesh mesh = new Mesh();
			mesh.Clear();
			mesh.name = "volumeClouds";
			mesh.vertices = array;
			mesh.triangles = array3;
			mesh.uv = array2;
			mesh.colors = array4;
			mesh.RecalculateNormals();
			mesh.RecalculateBounds();
			CalcMeshTangents(mesh);
			Components.VolumeCloudsLayer1.GetComponent<MeshFilter>().mesh = mesh;
			Components.VolumeCloudsLayer2.GetComponent<MeshFilter>().mesh = mesh;
		}
		else if (slices == 1)
		{
			Mesh mesh2 = new Mesh();
			mesh2.Clear();
			mesh2.name = "volumeCloudsShadows";
			mesh2.vertices = array;
			mesh2.triangles = array3;
			mesh2.uv = array2;
			mesh2.colors = array4;
			mesh2.RecalculateNormals();
			mesh2.RecalculateBounds();
			CalcMeshTangents(mesh2);
			Components.VolumeCloudsShadowsLayer1.GetComponent<MeshFilter>().mesh = mesh2;
			Components.VolumeCloudsShadowsLayer2.GetComponent<MeshFilter>().mesh = mesh2;
		}
	}

	public static void CalcMeshTangents(Mesh mesh)
	{
		int[] triangles = mesh.triangles;
		Vector3[] vertices = mesh.vertices;
		Vector2[] uv = mesh.uv;
		Vector3[] normals = mesh.normals;
		int num = triangles.Length;
		int num2 = vertices.Length;
		Vector3[] array = new Vector3[num2];
		Vector3[] array2 = new Vector3[num2];
		Vector4[] array3 = new Vector4[num2];
		for (long num3 = 0L; num3 < num; num3 += 3)
		{
			long num4 = triangles[num3];
			long num5 = triangles[num3 + 1];
			long num6 = triangles[num3 + 2];
			Vector3 vector = vertices[num4];
			Vector3 vector2 = vertices[num5];
			Vector3 vector3 = vertices[num6];
			Vector2 vector4 = uv[num4];
			Vector2 vector5 = uv[num5];
			Vector2 vector6 = uv[num6];
			float num7 = vector2.x - vector.x;
			float num8 = vector3.x - vector.x;
			float num9 = vector2.y - vector.y;
			float num10 = vector3.y - vector.y;
			float num11 = vector2.z - vector.z;
			float num12 = vector3.z - vector.z;
			float num13 = vector5.x - vector4.x;
			float num14 = vector6.x - vector4.x;
			float num15 = vector5.y - vector4.y;
			float num16 = vector6.y - vector4.y;
			float num17 = 1f / (num13 * num16 - num14 * num15);
			Vector3 vector7 = new Vector3((num16 * num7 - num15 * num8) * num17, (num16 * num9 - num15 * num10) * num17, (num16 * num11 - num15 * num12) * num17);
			Vector3 vector8 = new Vector3((num13 * num8 - num14 * num7) * num17, (num13 * num10 - num14 * num9) * num17, (num13 * num12 - num14 * num11) * num17);
			array[num4] += vector7;
			array[num5] += vector7;
			array[num6] += vector7;
			array2[num4] += vector8;
			array2[num5] += vector8;
			array2[num6] += vector8;
		}
		for (long num18 = 0L; num18 < num2; num18++)
		{
			Vector3 normal = normals[num18];
			Vector3 tangent = array[num18];
			Vector3.OrthoNormalize(ref normal, ref tangent);
			array3[num18].x = tangent.x;
			array3[num18].y = tangent.y;
			array3[num18].z = tangent.z;
			array3[num18].w = ((!(Vector3.Dot(Vector3.Cross(normal, tangent), array2[num18]) < 0f)) ? 1f : (-1f));
		}
		mesh.tangents = array3;
	}

	public void RegisterZone(EnviroZone zoneToAdd)
	{
		Weather.zones.Add(zoneToAdd);
	}

	public void EnterZone(EnviroZone zone)
	{
		Weather.currentActiveZone = zone;
	}

	public void ExitZone()
	{
	}

	public void CreateWeatherEffectHolder()
	{
		if (Weather.VFXHolder == null)
		{
			GameObject gameObject = new GameObject();
			gameObject.name = "VFX";
			gameObject.transform.parent = EffectsHolder.transform;
			gameObject.transform.localPosition = Vector3.zero;
			Weather.VFXHolder = gameObject;
		}
	}

	private void UpdateAudioSource(EnviroWeatherPrefab i)
	{
		if (i != null && i.Sfx != null)
		{
			if (i.Sfx == Weather.currentAudioSource.clip)
			{
				Weather.currentAudioSource.GetComponent<EnviroAudioSource>().FadeIn(i.Sfx);
			}
			else if (Weather.currentAudioSource == AudioSourceWeather)
			{
				AudioSourceWeather.GetComponent<EnviroAudioSource>().FadeOut();
				AudioSourceWeather2.GetComponent<EnviroAudioSource>().FadeIn(i.Sfx);
				Weather.currentAudioSource = AudioSourceWeather2;
			}
			else if (Weather.currentAudioSource == AudioSourceWeather2)
			{
				AudioSourceWeather2.GetComponent<EnviroAudioSource>().FadeOut();
				AudioSourceWeather.GetComponent<EnviroAudioSource>().FadeIn(i.Sfx);
				Weather.currentAudioSource = AudioSourceWeather;
			}
		}
		else
		{
			AudioSourceWeather.GetComponent<EnviroAudioSource>().FadeOut();
			AudioSourceWeather2.GetComponent<EnviroAudioSource>().FadeOut();
		}
	}

	private void UpdateClouds(EnviroWeatherPrefab i)
	{
		if (i != null)
		{
			Lighting.SunWeatherMod = i.sunLightMod;
			Clouds.FirstColor = Color.Lerp(Clouds.FirstColor, i.cloudConfig.FirstColor, Weather.cloudChangeSpeed);
			Clouds.SecondColor = Color.Lerp(Clouds.SecondColor, i.cloudConfig.SecondColor, Weather.cloudChangeSpeed);
			Clouds.DirectLightIntensity = Mathf.Lerp(Clouds.DirectLightIntensity, i.cloudConfig.DirectLightInfluence, Weather.cloudChangeSpeed);
			Clouds.AmbientLightIntensity = Mathf.Lerp(Clouds.AmbientLightIntensity, i.cloudConfig.AmbientLightInfluence, Weather.cloudChangeSpeed);
			Clouds.Coverage = Mathf.Lerp(Clouds.Coverage, i.cloudConfig.Coverage, Weather.cloudChangeSpeed);
			Clouds.Density = Mathf.Lerp(Clouds.Density, i.cloudConfig.Density, Weather.cloudChangeSpeed);
			Clouds.Alpha = Mathf.Lerp(Clouds.Alpha, i.cloudConfig.Alpha, Weather.cloudChangeSpeed);
			Clouds.Speed1 = Mathf.Lerp(Clouds.Speed1, i.cloudConfig.Speed1, 0.00025f * Time.deltaTime);
			Clouds.Speed2 = Mathf.Lerp(Clouds.Speed2, i.cloudConfig.Speed2, 0.00025f * Time.deltaTime);
			Sky.weatherMod = Color.Lerp(Sky.weatherMod, i.WeatherColorMod, Weather.cloudChangeSpeed);
		}
	}

	private void UpdateFog(EnviroWeatherPrefab i)
	{
		if (i != null)
		{
			if (Fog.Fogmode == FogMode.Linear)
			{
				RenderSettings.fogEndDistance = Mathf.Lerp(RenderSettings.fogEndDistance, i.fogDistance, 0.01f);
				RenderSettings.fogStartDistance = Mathf.Lerp(RenderSettings.fogStartDistance, i.fogStartDistance, 0.01f);
			}
			else
			{
				RenderSettings.fogDensity = Mathf.Lerp(RenderSettings.fogDensity, i.fogDensity, 0.01f);
			}
			if (Fog.AdvancedFog)
			{
				Fog.skyFogHeight = Mathf.Lerp(Fog.skyFogHeight, i.SkyFogHeight, Weather.cloudChangeSpeed);
				Fog.skyFogStrength = Mathf.Lerp(Fog.skyFogStrength, i.SkyFogIntensity, Weather.cloudChangeSpeed);
				Fog.scatteringStrenght = Mathf.Lerp(Fog.scatteringStrenght, i.FogScatteringIntensity, Weather.cloudChangeSpeed);
			}
		}
	}

	private void UpdateEffectSystems(EnviroWeatherPrefab id)
	{
		if (!(id != null))
		{
			return;
		}
		for (int i = 0; i < id.effectParticleSystems.Count; i++)
		{
			float emissionRate = Mathf.Lerp(GetEmissionRate(id.effectParticleSystems[i]), id.effectEmmisionRates[i] * Quality.GlobalParticleEmissionRates, Weather.effectChangeSpeed);
			SetEmissionRate(id.effectParticleSystems[i], emissionRate);
		}
		for (int j = 0; j < Weather.WeatherTemplates.Count; j++)
		{
			if (!(Weather.WeatherTemplates[j].gameObject != id.gameObject))
			{
				continue;
			}
			for (int k = 0; k < Weather.WeatherTemplates[j].effectParticleSystems.Count; k++)
			{
				float num = Mathf.Lerp(GetEmissionRate(Weather.WeatherTemplates[j].effectParticleSystems[k]), 0f, Weather.effectChangeSpeed);
				if (num < 1f)
				{
					num = 0f;
				}
				SetEmissionRate(Weather.WeatherTemplates[j].effectParticleSystems[k], num);
			}
		}
		Weather.windZone.windMain = id.WindStrenght;
		Weather.curWetness = Weather.wetness;
		Weather.wetness = Mathf.Lerp(Weather.curWetness, id.wetnessLevel, Weather.wetnessAccumulationSpeed * Time.deltaTime);
		Weather.wetness = Mathf.Clamp(Weather.wetness, 0f, 1f);
		Weather.curSnowStrenght = Weather.SnowStrenght;
		Weather.SnowStrenght = Mathf.Lerp(Weather.curSnowStrenght, id.snowLevel, Weather.snowAccumulationSpeed * Time.deltaTime);
		Weather.SnowStrenght = Mathf.Clamp(Weather.SnowStrenght, 0f, 1f);
	}

	public static float GetEmissionRate(ParticleSystem system)
	{
		return system.emission.rate.constantMax;
	}

	public static void SetEmissionRate(ParticleSystem sys, float emissionRate)
	{
		ParticleSystem.EmissionModule emission = sys.emission;
		ParticleSystem.MinMaxCurve rate = emission.rate;
		rate.constantMax = emissionRate;
		emission.rate = rate;
	}

	private IEnumerator PlayThunderRandom()
	{
		yield return new WaitForSeconds(UnityEngine.Random.Range(10, 20));
		int i = UnityEngine.Random.Range(0, Weather.ThunderSFX.Count);
		AudioSourceThunder.clip = Weather.ThunderSFX[i];
		AudioSourceThunder.loop = false;
		AudioSourceThunder.Play();
		Weather.LightningGenerator.Lightning();
		Weather.thundersfx = 0;
	}

	public void SetWeatherOverwrite(int weatherId)
	{
		if (Weather.WeatherTemplates[weatherId] != Weather.currentActiveWeatherID)
		{
			Weather.currentActiveZone.currentActiveZoneWeatherID = Weather.WeatherTemplates[weatherId];
		}
	}

	private void UpdateWeather()
	{
		if (Weather.currentActiveWeatherID != Weather.currentActiveZone.currentActiveZoneWeatherID)
		{
			Weather.lastActiveWeatherID = Weather.currentActiveWeatherID;
			Weather.currentActiveWeatherID = Weather.currentActiveZone.currentActiveZoneWeatherID;
			if (Weather.currentActiveWeatherID != null)
			{
				NotifyWeatherChanged(Weather.currentActiveWeatherID);
				UpdateAudioSource(Weather.currentActiveWeatherID);
			}
		}
		if (Weather.currentActiveWeatherID != null)
		{
			UpdateClouds(Weather.currentActiveWeatherID);
			UpdateFog(Weather.currentActiveWeatherID);
			UpdateEffectSystems(Weather.currentActiveWeatherID);
			if (Weather.thundersfx == 0 && (bool)Weather.currentActiveWeatherID && Weather.currentActiveWeatherID.isLightningStorm)
			{
				Weather.thundersfx = 1;
				StartCoroutine(PlayThunderRandom());
			}
		}
	}
}