You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1194 lines
61 KiB
1194 lines
61 KiB
using System; |
|
using System.Collections.Generic; |
|
|
|
namespace UnityEngine.AzureSky |
|
{ |
|
[ExecuteInEditMode] |
|
[AddComponentMenu("Azure[Sky]/Sky Controller")] |
|
public class AzureSkyController : MonoBehaviour |
|
{ |
|
#if UNITY_EDITOR |
|
public AzureEditorSettings editorSettings; |
|
#endif |
|
public static AzureSkyController Instance; |
|
//References. |
|
public Transform sunTransform; |
|
public Transform moonTransform; |
|
public Transform lightTransform; |
|
public Texture2D moonTexture; |
|
public Texture2D sunTexture; |
|
public Texture2D cloudNoise; |
|
public Cubemap starfieldTexture; |
|
public Cubemap starNoiseTexture; |
|
public Material skyMaterial; |
|
public Material rainMaterial; |
|
public Material snowMaterial; |
|
public ParticleSystem rainParticle; |
|
public ParticleSystem snowParticle; |
|
public Transform skydome; |
|
//灯光亮度倍增 |
|
public float LightAddition; |
|
|
|
//Internal uses. |
|
private DateTime m_date; |
|
private int m_dayOfYear = 1; |
|
private AzureSkyProfile m_getCalendarProfile; |
|
private Matrix4x4 m_starfieldMatrix; |
|
private Matrix4x4 m_noiseMatrix; |
|
private float m_noiseMatrixRotation = 0.0f; |
|
private Quaternion m_noiseRotation; |
|
private float m_timeSinceLastProbeUpdate; |
|
private float m_timelineCurveTime = 0.0f; |
|
private float m_timelineGradientTime = 0.0f; |
|
private float m_sunCurveTime = 0.0f; |
|
private float m_sunGradientTime = 0.0f; |
|
private float m_moonCurveTime = 0.0f; |
|
private float m_moonGradientTime = 0.0f; |
|
|
|
//Time of Day. |
|
private float m_timeProgression = 0.0f; |
|
private Vector3 m_sunRealisticPosition = Vector3.one; |
|
private Vector3 m_moonRealisticPosition = Vector3.one; |
|
private Quaternion m_sunSimplePosition; |
|
private Vector3 m_sunLocalDirection; |
|
private Vector3 m_moonLocalDirection; |
|
|
|
//Change Weather. |
|
public int weatherNumber = 0; |
|
public bool isBlendingWeathers = false; |
|
public float weatherTransitionTime = 0.0f; |
|
private float m_startTime = 0.0f; |
|
private float m_transitionTime = 30; |
|
|
|
//Profiles. |
|
public AzureSkyProfile[] calendarProfileList = new AzureSkyProfile[366]; |
|
public List<AzureSkyProfile> standardProfileList = new List<AzureSkyProfile>(); |
|
public List<WeatherProfile> weatherProfileList = new List<WeatherProfile>(); |
|
|
|
public AzureSkyProfile calendarDayProfile; |
|
private AzureSkyProfile nextCalendarDayProfile; |
|
public AzureSkyProfile currentDayProfile; |
|
|
|
public AzureSkyProfile sourceWeatherProfile; |
|
private AzureSkyProfile m_targetWeatherProfile; |
|
private WeightedDayProfile[] m_weightedProfiles; |
|
|
|
//Components. |
|
public AzureSkyTimeOfDayComponent timeOfDay = new AzureSkyTimeOfDayComponent(); |
|
public AzureSkyOptionsComponent options = new AzureSkyOptionsComponent(); |
|
|
|
//Scattering Properties of the Standard Sky System. |
|
public float kr = 8.4f; |
|
public float km = 1.25f; |
|
public float rayleigh = 1.0f; |
|
public float mie = 1.0f; |
|
public float nightIntensity = 2.5f; |
|
public float scattering = 0.25f; |
|
public float sunDiskIntensity = 3.0f; |
|
public float exposure = 1.0f; |
|
public Color mieColor = Color.white; |
|
public Color rayleighColor = Color.white; |
|
public Color sunDiskColor = Color.white; |
|
|
|
private Vector3 m_lambda = new Vector3(680.0f, 550.0f, 440.0f);//Wavelength. |
|
public float N = 2.545f;//Molecular density. 2.545E25f |
|
private const float m_pi = Mathf.PI;//Pi number value. |
|
private const float m_n = 1.00029f;//Refractive index of air. |
|
private const float m_pn = 0.035f;//Depolatization factor for standard air. |
|
private Vector3 m_K = new Vector3(686.0f, 678.0f, 666.0f); |
|
|
|
//Deep Space Properties. |
|
public Color moonColor = Color.white; |
|
public Color moonBrightColor = Color.white; |
|
public float moonBrightRange = 50.0f; |
|
public float moonEmission = 0.5f; |
|
public float starsScintillation = 5.0f; |
|
public float starfieldIntensity = 0.0f; |
|
public float milkyWayIntensity = 0.0f; |
|
|
|
//Fog Scattering Properties of the Standard Sky System. |
|
public float fogScale = 1.0f; |
|
public float fogBlend = 0.25f; |
|
public float fogDensity = 1.0f; |
|
public float fogDistance = 5000.0f; |
|
public float heightFogBlend = 1.0f; |
|
public float heightFogDensity = 0.5f; |
|
public float heightFogDistance = 500.0f; |
|
public float heightFogStart = 0.0f; |
|
public float heightFogEnd = 100.0f; |
|
|
|
//Clouds Properties. |
|
public float dynamicCloudLayer1Altitude = 10.0f; |
|
public float dynamicCloudLayer1Direction = 1.0f; |
|
public float dynamicCloudLayer1Speed = 0.1f; |
|
public Color dynamicCloudLayer1Color1 = Color.white; |
|
public Color dynamicCloudLayer1Color2 = Color.white; |
|
public float dynamicCloudLayer1Density = 0.7f; |
|
private Texture2D staticCloudTextureSource, staticCloudTextureDestination; |
|
public Color staticCloudColor = Color.white; |
|
public float staticCloudScattering = 1.0f; |
|
public float staticCloudExtinction = 0.25f; |
|
public float staticCloudPower = 2.2f; |
|
public float staticCloudIntensity = 1.0f; |
|
public float staticCloudRotationSpeed = 0.0f; |
|
private float m_cloudRotationSpeed = 0.0f; |
|
|
|
//Lighting Properties. |
|
public float lightIntensity = 1.0f; |
|
public Color lightColor = Color.black; |
|
public float ambientIntensity = 1.0f; |
|
public Color ambientSkyColor = Color.black; |
|
public Color ambientEquatorColor = Color.black; |
|
public Color ambientGroundColor = Color.black; |
|
public float reflectionIntensity = 1.0f; |
|
private Light m_lightComponent; |
|
private float m_sunElevation = 0.0f; |
|
|
|
//Weather Properties. |
|
public Color rainColor = Color.white; |
|
public Color snowColor = Color.white; |
|
public float rainIntensity = 0.0f; |
|
public float snowIntensity = 0.0f; |
|
public float windSpeed = 0.0f; |
|
public float windDirection = 0.0f; |
|
public float rainLightVolume = 0.0f; |
|
public float rainMediumVolume = 0.0f; |
|
public float rainHeavyVolume = 0.0f; |
|
public float windLightVolume = 0.0f; |
|
public float windMediumVolume = 0.0f; |
|
public float windHeavyVolume = 0.0f; |
|
public float wetness = 0.0f; |
|
public float snowAmount = 0.0f; |
|
public float covarage = 0.0f; |
|
public Color outputColor1 = Color.white; |
|
public Color outputColor2 = Color.white; |
|
public Color outputColor3 = Color.white; |
|
private ParticleSystem.EmissionModule m_rainEmission; |
|
private ParticleSystem.EmissionModule m_snowEmission; |
|
private float m_maxRainEmission = 2000.0f; |
|
private float m_maxSnowEmission = 750.0f; |
|
//private Vector3 m_windRotation = Vector3.zero; |
|
//private float m_maxWindSpeed = 10.0f; |
|
|
|
//Output Lists. |
|
public List<CurveOutput> curveOuputList = new List<CurveOutput>(); |
|
public List<GradientOutput> gradientOuputList = new List<GradientOutput>(); |
|
|
|
//Shader Uniforms. |
|
public static class Uniforms |
|
{ |
|
internal static readonly int _CullMode = Shader.PropertyToID("_Azure_CullMode"); |
|
internal static readonly int _SunTexture = Shader.PropertyToID("_Azure_SunTexture"); |
|
internal static readonly int _MoonTexture = Shader.PropertyToID("_Azure_MoonTexture"); |
|
internal static readonly int _CloudNoise= Shader.PropertyToID("_Azure_CloudNoise"); |
|
internal static readonly int _StarfieldTexture = Shader.PropertyToID("_Azure_StarfieldTexture"); |
|
internal static readonly int _StarNoiseTexture = Shader.PropertyToID("_Azure_StarNoiseTexture"); |
|
internal static readonly int _Kr = Shader.PropertyToID("_Azure_Kr"); |
|
internal static readonly int _Km = Shader.PropertyToID("_Azure_Km"); |
|
internal static readonly int _Scattering = Shader.PropertyToID("_Azure_Scattering"); |
|
internal static readonly int _NightIntensity = Shader.PropertyToID("_Azure_NightIntensity"); |
|
internal static readonly int _RayleighColor = Shader.PropertyToID("_Azure_RayleighColor"); |
|
internal static readonly int _MieColor = Shader.PropertyToID("_Azure_MieColor"); |
|
internal static readonly int _SunDiskIntensity = Shader.PropertyToID("_Azure_SunDiskIntensity"); |
|
internal static readonly int _SunDiskColor = Shader.PropertyToID("_Azure_SunDiskColor"); |
|
internal static readonly int _Exposure = Shader.PropertyToID("_Azure_Exposure"); |
|
internal static readonly int _Pi316 = Shader.PropertyToID("_Azure_Pi316"); |
|
internal static readonly int _Pi14 = Shader.PropertyToID("_Azure_Pi14"); |
|
internal static readonly int _Pi = Shader.PropertyToID("_Azure_Pi"); |
|
internal static readonly int _LightSpeed = Shader.PropertyToID("_Azure_LightSpeed"); |
|
internal static readonly int _MieDepth = Shader.PropertyToID("_Azure_MieDepth"); |
|
internal static readonly int _SunSize = Shader.PropertyToID("_Azure_SunSize"); |
|
internal static readonly int _MoonSize = Shader.PropertyToID("_Azure_MoonSize"); |
|
internal static readonly int _SunDirection = Shader.PropertyToID("_Azure_SunDirection"); |
|
internal static readonly int _MoonDirection = Shader.PropertyToID("_Azure_MoonDirection"); |
|
internal static readonly int _UpMatrix = Shader.PropertyToID("_Azure_UpMatrix"); |
|
internal static readonly int _MoonMatrix = Shader.PropertyToID("_Azure_MoonMatrix"); |
|
internal static readonly int _SunMatrix = Shader.PropertyToID("_Azure_SunMatrix"); |
|
internal static readonly int _RelativeSunMatrix = Shader.PropertyToID("_Azure_RelativeSunMatrix"); |
|
internal static readonly int _StarMatrix = Shader.PropertyToID("_Azure_StarMatrix"); |
|
internal static readonly int _NoiseMatrix = Shader.PropertyToID("_Azure_NoiseMatrix"); |
|
internal static readonly int _Br = Shader.PropertyToID("_Azure_Br"); |
|
internal static readonly int _Bm = Shader.PropertyToID("_Azure_Bm"); |
|
internal static readonly int _MieG = Shader.PropertyToID("_Azure_MieG"); |
|
internal static readonly int _SunsetColorMode = Shader.PropertyToID("_Azure_SunsetColorMode"); |
|
|
|
internal static readonly int _MoonColor = Shader.PropertyToID("_Azure_MoonColor"); |
|
internal static readonly int _MoonBrightColor = Shader.PropertyToID("_Azure_MoonBrightColor"); |
|
internal static readonly int _MoonBrightRange = Shader.PropertyToID("_Azure_MoonBrightRange"); |
|
internal static readonly int _MoonEmission = Shader.PropertyToID("_Azure_MoonEmission"); |
|
internal static readonly int _StarfieldColorBalance = Shader.PropertyToID("_Azure_StarfieldColorBalance"); |
|
internal static readonly int _StarfieldIntensity = Shader.PropertyToID("_Azure_StarfieldIntensity"); |
|
internal static readonly int _MilkyWayIntensity = Shader.PropertyToID("_Azure_MilkyWayIntensity"); |
|
|
|
internal static readonly int _FogScale = Shader.PropertyToID("_Azure_FogScale"); |
|
internal static readonly int _FogBlend = Shader.PropertyToID("_Azure_FogBlend"); |
|
internal static readonly int _FogDensity = Shader.PropertyToID("_Azure_FogDensity"); |
|
internal static readonly int _FogDistance = Shader.PropertyToID("_Azure_FogDistance"); |
|
internal static readonly int _HeightFogBlend = Shader.PropertyToID("_Azure_HeightFogBlend"); |
|
internal static readonly int _HeightFogDensity = Shader.PropertyToID("_Azure_HeightFogDensity"); |
|
internal static readonly int _HeightFogDistance = Shader.PropertyToID("_Azure_HeightFogDistance"); |
|
internal static readonly int _HeightFogStart = Shader.PropertyToID("_Azure_HeightFogStart"); |
|
internal static readonly int _HeightFogEnd = Shader.PropertyToID("_Azure_HeightFogEnd"); |
|
|
|
internal static readonly int _DynamicCloudLayer1Altitude = Shader.PropertyToID("_Azure_DynamicCloudLayer1Altitude"); |
|
internal static readonly int _DynamicCloudLayer1Direction = Shader.PropertyToID("_Azure_DynamicCloudLayer1Direction"); |
|
internal static readonly int _DynamicCloudLayer1Speed = Shader.PropertyToID("_Azure_DynamicCloudLayer1Speed"); |
|
internal static readonly int _DynamicCloudLayer1Density = Shader.PropertyToID("_Azure_DynamicCloudLayer1Density"); |
|
internal static readonly int _DynamicCloudLayer1Color1 = Shader.PropertyToID("_Azure_DynamicCloudLayer1Color1"); |
|
internal static readonly int _DynamicCloudLayer1Color2 = Shader.PropertyToID("_Azure_DynamicCloudLayer1Color2"); |
|
internal static readonly int _StaticCloudTextureSource = Shader.PropertyToID("_Azure_StaticCloudTextureSource"); |
|
internal static readonly int _StaticCloudTextureDestination = Shader.PropertyToID("_Azure_StaticCloudTextureDestination"); |
|
internal static readonly int _StaticCloudColor = Shader.PropertyToID("_Azure_StaticCloudColor"); |
|
internal static readonly int _StaticCloudScattering = Shader.PropertyToID("_Azure_StaticCloudScattering"); |
|
internal static readonly int _StaticCloudExtinction = Shader.PropertyToID("_Azure_StaticCloudExtinction"); |
|
internal static readonly int _StaticCloudPower = Shader.PropertyToID("_Azure_StaticCloudPower"); |
|
internal static readonly int _StaticCloudIntensity = Shader.PropertyToID("_Azure_StaticCloudIntensity"); |
|
internal static readonly int _StaticCloudRotationSpeed = Shader.PropertyToID("_Azure_StaticCloudRotationSpeed"); |
|
internal static readonly int _WeatherTransitionTime = Shader.PropertyToID("_Azure_WeatherTransitionTime"); |
|
|
|
internal static readonly int _RainColor = Shader.PropertyToID("_TintColor"); |
|
internal static readonly int _SnowColor = Shader.PropertyToID("_TintColor"); |
|
} |
|
|
|
// Read only. |
|
private bool m_isDaytime = false; |
|
public bool IsDaytime |
|
{ |
|
get |
|
{ |
|
return m_isDaytime; |
|
} |
|
} |
|
private void Awake() |
|
{ |
|
Instance = this; |
|
} |
|
//Start. |
|
void Start () |
|
{ |
|
weatherNumber = 0; |
|
m_rainEmission = rainParticle.emission; |
|
m_snowEmission = snowParticle.emission; |
|
|
|
// Get components. |
|
m_lightComponent = lightTransform.GetComponent<Light>(); |
|
|
|
//First Shaders Update. |
|
ConfigureShaders (); |
|
InitializeShaderUniforms (); |
|
UpdateShaderUniforms (); |
|
|
|
//Enable or Disable Particles. |
|
SetParticlesActive (options.particlesMode); |
|
|
|
//Initialize Profiles. |
|
UpdateProfiles (); |
|
|
|
//Set System Date and Time.(?) |
|
if (options.startAtCurrentDate) { timeOfDay.ApplySystemDate (); } |
|
if (options.startAtCurrentTime) { timeOfDay.ApplySystemTime (); } |
|
|
|
//Get the Progression Speed of the 24-hour Day Cycle. |
|
m_timeProgression = timeOfDay.GetDayLength (); |
|
|
|
} |
|
public void GetTimeProgression(float value) |
|
{ |
|
m_timeProgression = value; |
|
} |
|
|
|
//Reset the Calendar. |
|
void Reset () |
|
{ |
|
timeOfDay.UpdateCalendar (timeOfDay.selectableDayList); |
|
} |
|
|
|
//Update. |
|
void Update () |
|
{ |
|
// Update shader uniforms. |
|
UpdateShaderUniforms (); |
|
#if UNITY_EDITOR |
|
InitializeShaderUniforms (); |
|
#endif |
|
|
|
// Follow Main Camera. |
|
if (options.followMainCamera && Camera.main) |
|
{ |
|
transform.position = Camera.main.transform.position; |
|
} |
|
|
|
// Get Curves and Gradients time to evaluate. |
|
m_timelineGradientTime = timeOfDay.hour / 24.0f; |
|
m_timelineCurveTime = timeOfDay.hour; |
|
if (timeOfDay.setTimeByCurve) |
|
{ |
|
timeOfDay.CalculateTimeByCurve (); |
|
m_timelineGradientTime = timeOfDay.hourByCurve / 24.0f; |
|
m_timelineCurveTime = timeOfDay.hourByCurve; |
|
} |
|
m_sunCurveTime = Vector3.Dot(-sunTransform.transform.forward, transform.up); |
|
m_sunGradientTime = Mathf.InverseLerp(-1, 1, m_sunCurveTime); |
|
m_moonCurveTime = Vector3.Dot(-moonTransform.transform.forward, transform.up); |
|
m_moonGradientTime = Mathf.InverseLerp(-1, 1, m_moonCurveTime); |
|
|
|
// Update Properties. |
|
if (!isBlendingWeathers) |
|
{ |
|
N = currentDayProfile.scattering.N; |
|
kr = currentDayProfile.scattering.kr; |
|
km = currentDayProfile.scattering.km; |
|
m_lambda = currentDayProfile.scattering.lambda; |
|
rayleigh = GetCurveValue (currentDayProfile.scattering.rayleighCurve, currentDayProfile.scattering.rayleighCurveIndex); |
|
mie = GetCurveValue (currentDayProfile.scattering.mieCurve, currentDayProfile.scattering.mieCurveIndex); |
|
scattering = GetCurveValue(currentDayProfile.scattering.scatteringCurve, currentDayProfile.scattering.scatteringCurveIndex); |
|
nightIntensity = GetCurveValue (currentDayProfile.scattering.nightIntensityCurve, currentDayProfile.scattering.nightIntensityCurveIndex); |
|
sunDiskIntensity = GetCurveValue (currentDayProfile.scattering.sunDiskIntensityCurve, currentDayProfile.scattering.sunDiskIntensityCurveIndex); |
|
exposure = GetCurveValue (currentDayProfile.scattering.exposureCurve, currentDayProfile.scattering.exposureCurveIndex); |
|
rayleighColor = GetGradientValue (currentDayProfile.scattering.rayleighGradientColor, currentDayProfile.scattering.rayleighGradientIndex); |
|
mieColor = GetGradientValue (currentDayProfile.scattering.mieGradientColor, currentDayProfile.scattering.mieGradientIndex); |
|
sunDiskColor = GetGradientValue (currentDayProfile.scattering.sunDiskGradientColor, currentDayProfile.scattering.sunDiskGradientIndex); |
|
|
|
moonColor = GetGradientValue (currentDayProfile.deepSpace.moonColorGradientColor, currentDayProfile.deepSpace.moonColorGradientIndex); |
|
moonBrightColor = GetGradientValue (currentDayProfile.deepSpace.moonBrightColorGradientColor, currentDayProfile.deepSpace.moonBrightColorGradientIndex); |
|
moonBrightRange = GetCurveValue (currentDayProfile.deepSpace.moonBrightRangeCurve, currentDayProfile.deepSpace.moonBrightRangeCurveIndex); |
|
moonEmission = GetCurveValue (currentDayProfile.deepSpace.moonEmissionCurve, currentDayProfile.deepSpace.moonEmissionCurveIndex); |
|
starfieldIntensity = GetCurveValue (currentDayProfile.deepSpace.starfieldIntensityCurve, currentDayProfile.deepSpace.starfieldIntensityCurveIndex); |
|
milkyWayIntensity = GetCurveValue (currentDayProfile.deepSpace.milkyWayIntensityCurve, currentDayProfile.deepSpace.milkyWayIntensityCurveIndex); |
|
starsScintillation = currentDayProfile.deepSpace.starsScintillation; |
|
|
|
fogScale = currentDayProfile.fogScattering.fogScale; |
|
fogBlend = GetCurveValue (currentDayProfile.fogScattering.fogBlendCurve, currentDayProfile.fogScattering.fogBlendCurveIndex); |
|
fogDensity = GetCurveValue(currentDayProfile.fogScattering.fogDensityCurve, currentDayProfile.fogScattering.fogDensityCurveIndex); |
|
fogDistance = GetCurveValue (currentDayProfile.fogScattering.fogDistanceCurve, currentDayProfile.fogScattering.fogDistanceCurveIndex); |
|
heightFogBlend = GetCurveValue (currentDayProfile.fogScattering.heightFogBlendCurve, currentDayProfile.fogScattering.heightFogBlendCurveIndex); |
|
heightFogDensity = GetCurveValue (currentDayProfile.fogScattering.heightFogDensityCurve, currentDayProfile.fogScattering.heightFogDensityCurveIndex); |
|
heightFogDistance = GetCurveValue (currentDayProfile.fogScattering.heightFogDistanceCurve, currentDayProfile.fogScattering.heightFogDistanceCurveIndex); |
|
heightFogStart = GetCurveValue (currentDayProfile.fogScattering.heightFogStartCurve, currentDayProfile.fogScattering.heightFogStartCurveIndex); |
|
heightFogEnd = GetCurveValue (currentDayProfile.fogScattering.heightFogEndCurve, currentDayProfile.fogScattering.heightFogEndCurveIndex); |
|
|
|
switch (options.cloudMode) |
|
{ |
|
case 1: |
|
dynamicCloudLayer1Altitude = currentDayProfile.clouds.dynamicCloudLayer1Altitude; |
|
dynamicCloudLayer1Direction = currentDayProfile.clouds.dynamicCloudLayer1Direction; |
|
dynamicCloudLayer1Speed = currentDayProfile.clouds.dynamicCloudLayer1Speed; |
|
dynamicCloudLayer1Density = GetCurveValue (currentDayProfile.clouds.dynamicCloudLayer1DensityCurve, currentDayProfile.clouds.dynamicCloudLayer1DensityCurveIndex); |
|
dynamicCloudLayer1Color1 = GetGradientValue (currentDayProfile.clouds.dynamicCloudLayer1GradientColor1, currentDayProfile.clouds.dynamicCloudLayer1GradientColor1Index); |
|
dynamicCloudLayer1Color2 = GetGradientValue (currentDayProfile.clouds.dynamicCloudLayer1GradientColor2, currentDayProfile.clouds.dynamicCloudLayer1GradientColor2Index); |
|
break; |
|
case 2: |
|
//staticCloudTextureSource = currentDayProfile.clouds.staticCloudTexture; |
|
//staticCloudTextureDestination = currentDayProfile.clouds.staticCloudTexture; |
|
staticCloudColor = GetGradientValue(currentDayProfile.clouds.staticCloudColor, currentDayProfile.clouds.staticCloudColorIndex); |
|
staticCloudScattering = GetCurveValue(currentDayProfile.clouds.staticCloudScatteringCurve, currentDayProfile.clouds.staticCloudScatteringCurveIndex); |
|
staticCloudExtinction = GetCurveValue(currentDayProfile.clouds.staticCloudExtinctionCurve, currentDayProfile.clouds.staticCloudExtinctionCurveIndex); |
|
staticCloudPower = GetCurveValue(currentDayProfile.clouds.staticCloudPowerCurve, currentDayProfile.clouds.staticCloudPowerCurveIndex); |
|
staticCloudIntensity = GetCurveValue(currentDayProfile.clouds.staticCloudIntensityCurve, currentDayProfile.clouds.staticCloudIntensityCurveIndex); |
|
staticCloudRotationSpeed = currentDayProfile.clouds.staticCloudRotationSpeed; |
|
break; |
|
} |
|
|
|
lightIntensity = GetCurveValue (currentDayProfile.lighting.directionalLightIntensityCurve, currentDayProfile.lighting.directionalLightIntensityCurveIndex); |
|
lightColor = GetGradientValue (currentDayProfile.lighting.directionalLightGradientColor, currentDayProfile.lighting.directionalLightGradientColorIndex); |
|
ambientIntensity = GetCurveValue (currentDayProfile.lighting.ambientIntensityCurve, currentDayProfile.lighting.ambientIntensityCurveIndex); |
|
ambientSkyColor = GetGradientValue (currentDayProfile.lighting.ambientSkyGradientColor, currentDayProfile.lighting.ambientSkyGradientColorIndex); |
|
ambientEquatorColor = GetGradientValue (currentDayProfile.lighting.equatorGradientColor, currentDayProfile.lighting.equatorGradientColorIndex); |
|
ambientGroundColor = GetGradientValue (currentDayProfile.lighting.groundGradientColor, currentDayProfile.lighting.groundGradientColorIndex); |
|
reflectionIntensity = GetCurveValue (currentDayProfile.lighting.reflectionIntensityCurve, currentDayProfile.lighting.reflectionIntensityCurveIndex); |
|
|
|
if (options.particlesMode == 1 || options.keepWeatherUpdate) |
|
{ |
|
rainColor = GetGradientValue (currentDayProfile.weather.weatherRainGradientColor, currentDayProfile.weather.weatherRainGradientColorIndex); |
|
snowColor = GetGradientValue (currentDayProfile.weather.weatherSnowGradientColor, currentDayProfile.weather.weatherSnowGradientColorIndex); |
|
rainIntensity = GetCurveValue (currentDayProfile.weather.weatherRainIntensityCurve, currentDayProfile.weather.weatherRainIntensityCurveIndex); |
|
snowIntensity = GetCurveValue (currentDayProfile.weather.weatherSnowIntensityCurve, currentDayProfile.weather.weatherSnowIntensityCurveIndex); |
|
windSpeed = GetCurveValue (currentDayProfile.weather.weatherWindSpeedCurve, currentDayProfile.weather.weatherWindSpeedCurveIndex); |
|
windDirection = GetCurveValue (currentDayProfile.weather.weatherWindDirectionCurve, currentDayProfile.weather.weatherWindDirectionCurveIndex); |
|
rainLightVolume = currentDayProfile.weather.weatherRainLightVolume; |
|
rainMediumVolume = currentDayProfile.weather.weatherRainMediumVolume; |
|
rainHeavyVolume = currentDayProfile.weather.weatherRainHeavyVolume; |
|
windLightVolume = currentDayProfile.weather.weatherWindLightVolume; |
|
windMediumVolume = currentDayProfile.weather.weatherWindMediumVolume; |
|
windHeavyVolume = currentDayProfile.weather.weatherWindHeavyVolume; |
|
} |
|
|
|
if (options.keepWeatherUpdate) |
|
{ |
|
wetness = GetCurveValue (currentDayProfile.weather.weatherWetnessCurve, currentDayProfile.weather.weatherWetnessCurveIndex); |
|
snowAmount = GetCurveValue (currentDayProfile.weather.weatherSnowAmountCurve, currentDayProfile.weather.weatherSnowAmountCurveIndex); |
|
covarage = GetCurveValue (currentDayProfile.weather.weatherCovarageCurve, currentDayProfile.weather.weatherCovarageCurveIndex); |
|
outputColor1 = GetGradientValue (currentDayProfile.weather.weatherOutputColor1GradientColor, currentDayProfile.weather.weatherOutputColor1Index); |
|
outputColor2 = GetGradientValue (currentDayProfile.weather.weatherOutputColor2GradientColor, currentDayProfile.weather.weatherOutputColor2Index); |
|
outputColor3 = GetGradientValue (currentDayProfile.weather.weatherOutputColor3GradientColor, currentDayProfile.weather.weatherOutputColor3Index); |
|
} |
|
} |
|
|
|
// Directions. |
|
m_sunLocalDirection = transform.InverseTransformDirection(sunTransform.transform.forward); |
|
m_moonLocalDirection = transform.InverseTransformDirection(moonTransform.transform.forward); |
|
|
|
//Only in Gameplay. |
|
if (Application.isPlaying) |
|
{ |
|
//Set Time of Day. |
|
timeOfDay.hour += m_timeProgression * Time.deltaTime; |
|
if (timeOfDay.hour >= 24) |
|
{ |
|
//Change to the next day. |
|
timeOfDay.StartNextDay (options.repeatMode); |
|
|
|
//Apply day change transition. |
|
if(options.applyDayChangeTransition && weatherNumber == 0 && calendarDayProfile != nextCalendarDayProfile) |
|
{ |
|
SetNewWeatherProfile(-1); |
|
} |
|
|
|
//Update calendar and profiles. |
|
UpdateProfiles (); |
|
} |
|
|
|
//Blend Weathers. |
|
if (isBlendingWeathers) |
|
{ |
|
BlendingWeathers (); |
|
} |
|
|
|
//Rotate Static Clouds |
|
if (staticCloudRotationSpeed != 0.0f) |
|
{ |
|
m_cloudRotationSpeed += staticCloudRotationSpeed * Time.deltaTime; |
|
if (m_cloudRotationSpeed >= 1.0f) |
|
{ |
|
m_cloudRotationSpeed -= 1.0f; |
|
} |
|
} |
|
} |
|
|
|
//Set the Position of the Sun and Moon in the Sky. |
|
switch (timeOfDay.timeMode) |
|
{ |
|
//Simple Time Mode. |
|
case 0: |
|
//Set the Rotation of Directional Lights. |
|
m_sunSimplePosition = Quaternion.Euler(0.0f, timeOfDay.longitude, timeOfDay.latitude); |
|
m_sunSimplePosition *= Quaternion.Euler(timeOfDay.SetSimpleSunPosition(), 180.0f, 0.0f); |
|
sunTransform.transform.localRotation = m_sunSimplePosition; |
|
moonTransform.transform.rotation = timeOfDay.SetSimpleMoonPosition(sunTransform); |
|
|
|
//Fix Skydome Local Rotation. |
|
skydome.transform.localRotation = Quaternion.Inverse(transform.rotation); |
|
|
|
//Update Shader Matrix. |
|
Shader.SetGlobalMatrix(Uniforms._UpMatrix, transform.worldToLocalMatrix); |
|
Shader.SetGlobalMatrix(Uniforms._SunMatrix, sunTransform.transform.worldToLocalMatrix); |
|
Shader.SetGlobalMatrix(Uniforms._RelativeSunMatrix, sunTransform.transform.worldToLocalMatrix * Matrix4x4.TRS(Vector3.zero, Quaternion.Inverse(transform.rotation), Vector3.one).inverse); |
|
Shader.SetGlobalMatrix(Uniforms._StarMatrix, Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(options.starfieldPosition), Vector3.one).inverse); |
|
break; |
|
|
|
//Realistic Time Mode. |
|
case 1: |
|
//Set the Rotation of Directional Lights. |
|
m_sunRealisticPosition = timeOfDay.SetRealisticSunPosition(); |
|
sunTransform.transform.forward = transform.TransformDirection(m_sunRealisticPosition); |
|
m_moonRealisticPosition = timeOfDay.SetRealisticMoonPosition(); |
|
moonTransform.transform.forward = transform.TransformDirection(m_moonRealisticPosition); |
|
|
|
//Fix Skydome Local Rotation. |
|
skydome.transform.localRotation = Quaternion.Inverse(transform.rotation); |
|
|
|
//Update Shader Matrix. |
|
Shader.SetGlobalMatrix(Uniforms._UpMatrix, transform.worldToLocalMatrix); |
|
Shader.SetGlobalMatrix(Uniforms._SunMatrix, sunTransform.transform.worldToLocalMatrix); |
|
Shader.SetGlobalMatrix(Uniforms._RelativeSunMatrix, Matrix4x4.identity); |
|
Quaternion skyRotation = Quaternion.Euler(90.0f - timeOfDay.latitude, 0.0f, 0.0f) * Quaternion.Euler(0.0f, timeOfDay.longitude, 0.0f) * Quaternion.Euler(0.0f, timeOfDay.lst * Mathf.Rad2Deg, 0.0f); |
|
m_starfieldMatrix = Matrix4x4.TRS(Vector3.zero, skyRotation * Quaternion.Euler(options.starfieldPosition), Vector3.one); |
|
Shader.SetGlobalMatrix(Uniforms._StarMatrix, m_starfieldMatrix.inverse); |
|
break; |
|
} |
|
|
|
// Get sun elevation and set light position. |
|
m_sunElevation = Vector3.Dot(-sunTransform.transform.forward, transform.up); |
|
if (m_sunElevation >= 0.0f) |
|
{ |
|
lightTransform.transform.localRotation = Quaternion.LookRotation(m_sunLocalDirection); |
|
m_isDaytime = true; |
|
} |
|
else |
|
{ |
|
lightTransform.transform.localRotation = Quaternion.LookRotation(m_moonLocalDirection); |
|
m_isDaytime = false; |
|
} |
|
|
|
//Lighting and Reflections. |
|
m_lightComponent.intensity = lightIntensity+LightAddition; |
|
m_lightComponent.color = lightColor; |
|
RenderSettings.ambientIntensity = ambientIntensity; |
|
RenderSettings.ambientSkyColor = ambientSkyColor; |
|
RenderSettings.ambientEquatorColor = ambientEquatorColor; |
|
RenderSettings.ambientGroundColor = ambientGroundColor; |
|
|
|
//Particles Controller. |
|
if (options.particlesMode == 1) |
|
{ |
|
//Rain Particle. |
|
if (rainIntensity > 0) |
|
{ |
|
if (rainParticle.isStopped) |
|
{ |
|
rainParticle.Play (); |
|
m_rainEmission = rainParticle.emission; |
|
} |
|
m_rainEmission.rateOverTime = rainIntensity * m_maxRainEmission; |
|
} |
|
else |
|
{ |
|
if (rainParticle.isPlaying) |
|
{ |
|
rainParticle.Stop (); |
|
} |
|
} |
|
|
|
//Snow Particle. |
|
if (snowIntensity > 0) |
|
{ |
|
if (snowParticle.isStopped) |
|
{ |
|
snowParticle.Play (); |
|
m_snowEmission = snowParticle.emission; |
|
} |
|
m_snowEmission.rateOverTime = snowIntensity * m_maxSnowEmission; |
|
} |
|
else |
|
{ |
|
if (snowParticle.isPlaying) |
|
{ |
|
snowParticle.Stop (); |
|
} |
|
} |
|
} |
|
|
|
|
|
//Stars Scintillation. |
|
if (starsScintillation > 0.0f) |
|
{ |
|
m_noiseMatrixRotation += starsScintillation * Time.deltaTime; |
|
m_noiseRotation = Quaternion.Euler(m_noiseMatrixRotation, m_noiseMatrixRotation, m_noiseMatrixRotation); |
|
m_noiseMatrix = Matrix4x4.TRS(Vector3.zero, m_noiseRotation, new Vector3(1, 1, 1)); |
|
} |
|
|
|
#if UNITY_EDITOR |
|
if(!Application.isPlaying) |
|
currentDayProfile = GetCalendarDayProfile(); |
|
#endif |
|
} |
|
|
|
//Calcule Total Rayleigh. |
|
private Vector3 GetBetaRay () |
|
{ |
|
//Converting the wavelength values given in Inspector for real scale used in formula. |
|
Vector3 converted_lambda = m_lambda * 1.0e-9f; |
|
float converted_N = N * 1.0e25f; |
|
|
|
Vector3 Br; |
|
Br.x = ((8.0f * Mathf.Pow(m_pi, 3.0f) * (Mathf.Pow(Mathf.Pow(m_n, 2.0f) - 1.0f, 2.0f))) / (3.0f * converted_N * Mathf.Pow(converted_lambda.x, 4.0f))) * 1000.0f; |
|
Br.y = ((8.0f * Mathf.Pow(m_pi, 3.0f) * (Mathf.Pow(Mathf.Pow(m_n, 2.0f) - 1.0f, 2.0f))) / (3.0f * converted_N * Mathf.Pow(converted_lambda.y, 4.0f))) * 1000.0f; |
|
Br.z = ((8.0f * Mathf.Pow(m_pi, 3.0f) * (Mathf.Pow(Mathf.Pow(m_n, 2.0f) - 1.0f, 2.0f))) / (3.0f * converted_N * Mathf.Pow(converted_lambda.z, 4.0f))) * 1000.0f; |
|
|
|
//Original equation. |
|
//Br.x = (((8.0f * Mathf.Pow(m_pi, 3.0f) * (Mathf.Pow(Mathf.Pow(m_n, 2.0f) - 1.0f, 2.0f)))*(6.0f+3.0f*m_pn) ) / ((3.0f * m_N * Mathf.Pow(converted_lambda.x, 4.0f))*(6.0f-7.0f*m_pn) ))*1000.0f; |
|
//Br.y = (((8.0f * Mathf.Pow(m_pi, 3.0f) * (Mathf.Pow(Mathf.Pow(m_n, 2.0f) - 1.0f, 2.0f)))*(6.0f+3.0f*m_pn) ) / ((3.0f * m_N * Mathf.Pow(converted_lambda.y, 4.0f))*(6.0f-7.0f*m_pn) ))*1000.0f; |
|
//Br.z = (((8.0f * Mathf.Pow(m_pi, 3.0f) * (Mathf.Pow(Mathf.Pow(m_n, 2.0f) - 1.0f, 2.0f)))*(6.0f+3.0f*m_pn) ) / ((3.0f * m_N * Mathf.Pow(converted_lambda.z, 4.0f))*(6.0f-7.0f*m_pn) ))*1000.0f; |
|
|
|
return Br; |
|
} |
|
|
|
//Calcule Total Mie. |
|
private Vector3 GetBetaMie () |
|
{ |
|
//float c = (6544f * Turbidity - 6510f) * 10.0f; |
|
float c = (0.2f * 2.0f) * 10.0f; |
|
Vector3 Bm; |
|
Bm.x = (434.0f * c * m_pi * Mathf.Pow((2.0f * m_pi) / m_lambda.x, 2.0f) * m_K.x) / 3.0f; |
|
Bm.y = (434.0f * c * m_pi * Mathf.Pow((2.0f * m_pi) / m_lambda.y, 2.0f) * m_K.y) / 3.0f; |
|
Bm.z = (434.0f * c * m_pi * Mathf.Pow((2.0f * m_pi) / m_lambda.z, 2.0f) * m_K.z) / 3.0f; |
|
|
|
Bm.x = Mathf.Pow(Bm.x, -1.0f); |
|
Bm.y = Mathf.Pow(Bm.y, -1.0f); |
|
Bm.z = Mathf.Pow(Bm.z, -1.0f); |
|
|
|
return Bm; |
|
} |
|
|
|
//Evaluate the Curve Properties. |
|
private float GetCurveValue (AnimationCurve[] curveTarget, int curveMode) |
|
{ |
|
switch (curveMode) |
|
{ |
|
//Based on Timeline. |
|
case 0: |
|
return curveTarget[0].Evaluate(m_timelineCurveTime); |
|
|
|
//Based on Sun Elevation. |
|
case 1: |
|
return curveTarget[1].Evaluate(m_sunCurveTime); |
|
|
|
//Based on Moon Elevation. |
|
case 2: |
|
return curveTarget[2].Evaluate(m_moonCurveTime); |
|
} |
|
return 0; |
|
} |
|
|
|
/// <summary> |
|
/// Get curve output and return as a Float. |
|
/// </summary> |
|
/// <param name="element">The element number of the Curve Output list.</param> |
|
/// <returns></returns> |
|
public float GetCurveOutput (int element) |
|
{ |
|
int curveMode = curveOuputList[element].curveIndex; |
|
switch (curveMode) |
|
{ |
|
case 0: |
|
return curveOuputList[element].curveOutput[0].Evaluate(m_timelineCurveTime); |
|
case 1: |
|
return curveOuputList[element].curveOutput[1].Evaluate(m_sunCurveTime); |
|
case 2: |
|
return curveOuputList[element].curveOutput[2].Evaluate(m_moonCurveTime); |
|
} |
|
return 0; |
|
} |
|
|
|
//Evaluate the Gradient Properties. |
|
private Color GetGradientValue (Gradient[] gradientTarget, int curveMode) |
|
{ |
|
switch (curveMode) |
|
{ |
|
//Based on Timeline. |
|
case 0: |
|
return gradientTarget[0].Evaluate(m_timelineGradientTime); |
|
|
|
//Based on Sun Elevation. |
|
case 1: |
|
return gradientTarget[1].Evaluate(m_sunGradientTime); |
|
|
|
//Based on Moon Elevation. |
|
case 2: |
|
return gradientTarget[2].Evaluate(m_moonGradientTime); |
|
} |
|
return Color.white; |
|
} |
|
|
|
/// <summary> |
|
/// Get gradient output and return as a Color. |
|
/// </summary> |
|
/// <param name="element">The element number of the Gradient Output list.</param> |
|
/// <returns></returns> |
|
public Color GetGradientOutput (int element) |
|
{ |
|
int gradientMode = gradientOuputList[element].gradientIndex; |
|
switch (gradientMode) |
|
{ |
|
case 0: |
|
return gradientOuputList[element].gradientOutput[0].Evaluate(m_timelineGradientTime); |
|
case 1: |
|
return gradientOuputList[element].gradientOutput[1].Evaluate(m_sunGradientTime); |
|
case 2: |
|
return gradientOuputList[element].gradientOutput[2].Evaluate(m_moonGradientTime); |
|
} |
|
return Color.white; |
|
} |
|
|
|
/// <summary> |
|
/// Get the current day profile from the calendar. It will return a random standard profile if there is no day profile attached to the current calendar day. |
|
/// </summary> |
|
/// <returns></returns> |
|
public AzureSkyProfile GetCalendarDayProfile () |
|
{ |
|
m_dayOfYear = timeOfDay.GetDayOfYear (); |
|
if (calendarProfileList[m_dayOfYear]) |
|
{ |
|
m_getCalendarProfile = calendarProfileList[m_dayOfYear]; |
|
} |
|
else |
|
{ |
|
m_getCalendarProfile = standardProfileList[Random.Range(0, (int)standardProfileList.Count)]; |
|
} |
|
return m_getCalendarProfile; |
|
} |
|
|
|
/// <summary> |
|
/// Get the next day profile from the calendar. It will return a random standard profile if there is no day profile attached to the next calendar day. |
|
/// </summary> |
|
/// <returns></returns> |
|
public AzureSkyProfile GetNextCalendarDayProfile() |
|
{ |
|
m_dayOfYear = timeOfDay.GetDayOfYear(); |
|
if (m_dayOfYear < 365) |
|
{ |
|
if (calendarProfileList[m_dayOfYear + 1]) |
|
{ |
|
m_getCalendarProfile = calendarProfileList[m_dayOfYear + 1]; |
|
} |
|
else |
|
{ |
|
m_getCalendarProfile = standardProfileList[Random.Range(0, (int)standardProfileList.Count)]; |
|
} |
|
} |
|
else |
|
{ |
|
if (calendarProfileList[0]) |
|
{ |
|
m_getCalendarProfile = calendarProfileList[0]; |
|
} |
|
else |
|
{ |
|
m_getCalendarProfile = standardProfileList[Random.Range(0, (int)standardProfileList.Count)]; |
|
} |
|
} |
|
return m_getCalendarProfile; |
|
} |
|
|
|
/// <summary> |
|
/// Changes the weather with a smooth transition. |
|
/// </summary> |
|
/// <param name="target">The profile number from the Inspector's "Weather Profiles" list.</param> |
|
public void SetNewWeatherProfile (int target) |
|
{ |
|
if (!isBlendingWeathers) |
|
{ |
|
switch (target) |
|
{ |
|
case -1: |
|
//Call next calendar day profile. |
|
m_transitionTime = options.dayChangeTransitionTime; |
|
m_targetWeatherProfile = nextCalendarDayProfile; |
|
break; |
|
|
|
case 0: |
|
//Call Default Weather. |
|
m_transitionTime = weatherProfileList [target].TransitionTime; |
|
m_targetWeatherProfile = calendarDayProfile; |
|
break; |
|
|
|
default: |
|
m_transitionTime = weatherProfileList[target].TransitionTime; |
|
m_targetWeatherProfile = weatherProfileList[target].Profile; |
|
break; |
|
} |
|
|
|
weatherTransitionTime = 0.0f; |
|
m_startTime = Time.time; |
|
isBlendingWeathers = true; |
|
weatherNumber = target; |
|
if (weatherNumber < 0) weatherNumber = 0; |
|
SetStaticCloudTexture(sourceWeatherProfile.clouds.staticCloudTexture, m_targetWeatherProfile.clouds.staticCloudTexture); |
|
} |
|
else |
|
{ |
|
Debug.Log("A weather transition is still in progress."); |
|
} |
|
} |
|
|
|
//Blending Weather Profiles. |
|
private void BlendingWeathers () |
|
{ |
|
//HACK. |
|
if (weatherNumber == 0 && !isBlendingWeathers) { sourceWeatherProfile = calendarDayProfile; } |
|
|
|
weatherTransitionTime = Mathf.Clamp01((Time.time - m_startTime) / m_transitionTime); |
|
SetWeightedProfiles(new WeightedDayProfile(sourceWeatherProfile, 1.0f - weatherTransitionTime), new WeightedDayProfile(m_targetWeatherProfile, weatherTransitionTime)); |
|
BlendWeatherProfiles(m_weightedProfiles); |
|
Shader.SetGlobalFloat(Uniforms._WeatherTransitionTime, weatherTransitionTime); |
|
if (weatherTransitionTime == 1.0f) |
|
{ |
|
isBlendingWeathers = false; |
|
weatherTransitionTime = 0.0f; |
|
m_startTime = 0.0f; |
|
sourceWeatherProfile = m_targetWeatherProfile; |
|
currentDayProfile = m_targetWeatherProfile; |
|
SetStaticCloudTexture(currentDayProfile.clouds.staticCloudTexture, currentDayProfile.clouds.staticCloudTexture); |
|
} |
|
} |
|
|
|
private void SetWeightedProfiles (params WeightedDayProfile[] profiles) |
|
{ |
|
m_weightedProfiles = profiles; |
|
} |
|
|
|
//Based on PlayWayWater weight system. |
|
private void BlendWeatherProfiles (WeightedDayProfile[] profiles) |
|
{ |
|
N = 0.0f; |
|
kr = 0.0f; |
|
km = 0.0f; |
|
m_lambda = Vector3.zero; |
|
rayleigh = 0; |
|
mie = 0.0f; |
|
scattering = 0.0f; |
|
nightIntensity = 0.0f; |
|
sunDiskIntensity = 0.0f; |
|
exposure = 0.0f; |
|
rayleighColor = Color.black; |
|
mieColor = Color.black; |
|
sunDiskColor = Color.black; |
|
|
|
moonColor = Color.black; |
|
moonBrightColor = Color.black; |
|
moonBrightRange = 0.0f; |
|
moonEmission = 0.0f; |
|
starsScintillation = 0.0f; |
|
starfieldIntensity = 0.0f; |
|
milkyWayIntensity = 0.0f; |
|
|
|
fogScale = 0.0f; |
|
fogBlend = 0.0f; |
|
fogDensity = 0.0f; |
|
fogDistance = 0.0f; |
|
heightFogBlend = 0.0f; |
|
heightFogDensity = 0.0f; |
|
heightFogDistance = 0.0f; |
|
heightFogStart = 0.0f; |
|
heightFogEnd = 0.0f; |
|
|
|
dynamicCloudLayer1Altitude = 0.0f; |
|
dynamicCloudLayer1Direction = 0.0f; |
|
dynamicCloudLayer1Speed = 0.0f; |
|
dynamicCloudLayer1Color1 = Color.black; |
|
dynamicCloudLayer1Color2 = Color.black; |
|
dynamicCloudLayer1Density = 0.0f; |
|
staticCloudColor = Color.black; |
|
staticCloudScattering = 0.0f; |
|
staticCloudExtinction = 0.0f; |
|
staticCloudPower = 0.0f; |
|
staticCloudIntensity = 0.0f; |
|
staticCloudRotationSpeed = 0.0f; |
|
|
|
lightIntensity = 0.0f; |
|
lightColor = Color.black; |
|
ambientIntensity = 0.0f; |
|
ambientSkyColor = Color.black; |
|
ambientEquatorColor = Color.black; |
|
ambientGroundColor = Color.black; |
|
reflectionIntensity = 0.0f; |
|
|
|
rainColor = Color.black; |
|
snowColor = Color.black; |
|
rainIntensity = 0.0f; |
|
snowIntensity = 0.0f; |
|
windSpeed = 0.0f; |
|
windDirection = 0.0f; |
|
rainLightVolume = 0.0f; |
|
rainMediumVolume = 0.0f; |
|
rainHeavyVolume = 0.0f; |
|
windLightVolume = 0.0f; |
|
windMediumVolume = 0.0f; |
|
windHeavyVolume = 0.0f; |
|
wetness = 0.0f; |
|
snowAmount = 0.0f; |
|
covarage = 0.0f; |
|
outputColor1 = Color.black; |
|
outputColor2 = Color.black; |
|
outputColor3 = Color.black; |
|
|
|
for (int i = 0; i < profiles.Length; ++i) |
|
{ |
|
var profile = profiles[i].profile; |
|
float weight = profiles[i].weight; |
|
|
|
N += profile.scattering.N * weight; |
|
kr += profile.scattering.kr * weight; |
|
km += profile.scattering.km * weight; |
|
m_lambda += profile.scattering.lambda * weight; |
|
rayleigh += GetCurveValue (profile.scattering.rayleighCurve, profile.scattering.rayleighCurveIndex) * weight; |
|
mie += GetCurveValue (profile.scattering.mieCurve, profile.scattering.mieCurveIndex) * weight; |
|
scattering += GetCurveValue(profile.scattering.scatteringCurve, profile.scattering.scatteringCurveIndex) * weight; |
|
nightIntensity += GetCurveValue (profile.scattering.nightIntensityCurve, profile.scattering.nightIntensityCurveIndex) * weight; |
|
sunDiskIntensity += GetCurveValue (profile.scattering.sunDiskIntensityCurve, profile.scattering.sunDiskIntensityCurveIndex) * weight; |
|
exposure += GetCurveValue (profile.scattering.exposureCurve, profile.scattering.exposureCurveIndex) * weight; |
|
rayleighColor += GetGradientValue (profile.scattering.rayleighGradientColor, profile.scattering.rayleighGradientIndex) * weight; |
|
mieColor += GetGradientValue (profile.scattering.mieGradientColor, profile.scattering.mieGradientIndex) * weight; |
|
sunDiskColor += GetGradientValue (profile.scattering.sunDiskGradientColor, profile.scattering.sunDiskGradientIndex) * weight; |
|
|
|
moonColor += GetGradientValue (profile.deepSpace.moonColorGradientColor, profile.deepSpace.moonColorGradientIndex) * weight; |
|
moonBrightColor += GetGradientValue (profile.deepSpace.moonBrightColorGradientColor, profile.deepSpace.moonBrightColorGradientIndex) * weight; |
|
moonBrightRange += GetCurveValue (profile.deepSpace.moonBrightRangeCurve, profile.deepSpace.moonBrightRangeCurveIndex) * weight; |
|
moonEmission += GetCurveValue (profile.deepSpace.moonEmissionCurve, profile.deepSpace.moonEmissionCurveIndex) * weight; |
|
starsScintillation += profile.deepSpace.starsScintillation * weight; |
|
starfieldIntensity += GetCurveValue (profile.deepSpace.starfieldIntensityCurve, profile.deepSpace.starfieldIntensityCurveIndex) * weight; |
|
milkyWayIntensity += GetCurveValue (profile.deepSpace.milkyWayIntensityCurve, profile.deepSpace.milkyWayIntensityCurveIndex) * weight; |
|
|
|
fogScale += profile.fogScattering.fogScale * weight; |
|
fogBlend += GetCurveValue (profile.fogScattering.fogBlendCurve, profile.fogScattering.fogBlendCurveIndex) * weight; |
|
fogDensity += GetCurveValue(profile.fogScattering.fogDensityCurve, profile.fogScattering.fogDensityCurveIndex) * weight; |
|
fogDistance += GetCurveValue (profile.fogScattering.fogDistanceCurve, profile.fogScattering.fogDistanceCurveIndex) * weight; |
|
heightFogBlend += GetCurveValue (profile.fogScattering.heightFogBlendCurve, profile.fogScattering.heightFogBlendCurveIndex) * weight; |
|
heightFogDensity += GetCurveValue (profile.fogScattering.heightFogDensityCurve, profile.fogScattering.heightFogDensityCurveIndex) * weight; |
|
heightFogDistance += GetCurveValue (profile.fogScattering.heightFogDistanceCurve, profile.fogScattering.heightFogDistanceCurveIndex) * weight; |
|
heightFogStart += GetCurveValue (profile.fogScattering.heightFogStartCurve, profile.fogScattering.heightFogStartCurveIndex) * weight; |
|
heightFogEnd += GetCurveValue (profile.fogScattering.heightFogEndCurve, profile.fogScattering.heightFogEndCurveIndex) * weight; |
|
|
|
switch (options.cloudMode) |
|
{ |
|
case 1: |
|
dynamicCloudLayer1Altitude += profile.clouds.dynamicCloudLayer1Altitude * weight; |
|
dynamicCloudLayer1Direction += profile.clouds.dynamicCloudLayer1Direction * weight; |
|
dynamicCloudLayer1Speed += profile.clouds.dynamicCloudLayer1Speed * weight; |
|
dynamicCloudLayer1Density += GetCurveValue (profile.clouds.dynamicCloudLayer1DensityCurve, profile.clouds.dynamicCloudLayer1DensityCurveIndex) * weight; |
|
dynamicCloudLayer1Color1 += GetGradientValue (profile.clouds.dynamicCloudLayer1GradientColor1, profile.clouds.dynamicCloudLayer1GradientColor1Index) * weight; |
|
dynamicCloudLayer1Color2 += GetGradientValue (profile.clouds.dynamicCloudLayer1GradientColor2, profile.clouds.dynamicCloudLayer1GradientColor2Index) * weight; |
|
break; |
|
|
|
case 2: |
|
staticCloudColor += GetGradientValue(profile.clouds.staticCloudColor, profile.clouds.staticCloudColorIndex) * weight; |
|
staticCloudScattering += GetCurveValue(profile.clouds.staticCloudScatteringCurve, profile.clouds.staticCloudScatteringCurveIndex) * weight; |
|
staticCloudExtinction += GetCurveValue(profile.clouds.staticCloudExtinctionCurve, profile.clouds.staticCloudExtinctionCurveIndex) * weight; |
|
staticCloudPower += GetCurveValue(profile.clouds.staticCloudPowerCurve, profile.clouds.staticCloudPowerCurveIndex) * weight; |
|
staticCloudIntensity += GetCurveValue(profile.clouds.staticCloudIntensityCurve, profile.clouds.staticCloudIntensityCurveIndex) * weight; |
|
staticCloudRotationSpeed += profile.clouds.staticCloudRotationSpeed * weight; |
|
break; |
|
} |
|
|
|
lightIntensity += GetCurveValue (profile.lighting.directionalLightIntensityCurve, profile.lighting.directionalLightIntensityCurveIndex) * weight; |
|
lightColor += GetGradientValue (profile.lighting.directionalLightGradientColor, profile.lighting.directionalLightGradientColorIndex) * weight; |
|
ambientIntensity += GetCurveValue (profile.lighting.ambientIntensityCurve, profile.lighting.ambientIntensityCurveIndex) * weight; |
|
ambientSkyColor += GetGradientValue (profile.lighting.ambientSkyGradientColor, profile.lighting.ambientSkyGradientColorIndex) * weight; |
|
ambientEquatorColor += GetGradientValue (profile.lighting.equatorGradientColor, profile.lighting.equatorGradientColorIndex) * weight; |
|
ambientGroundColor += GetGradientValue (profile.lighting.groundGradientColor, profile.lighting.groundGradientColorIndex) * weight; |
|
reflectionIntensity += GetCurveValue (profile.lighting.reflectionIntensityCurve, profile.lighting.reflectionIntensityCurveIndex) * weight; |
|
|
|
if (options.particlesMode == 1 || options.keepWeatherUpdate) |
|
{ |
|
rainColor += GetGradientValue (profile.weather.weatherRainGradientColor, profile.weather.weatherRainGradientColorIndex) * weight; |
|
snowColor += GetGradientValue (profile.weather.weatherSnowGradientColor, profile.weather.weatherSnowGradientColorIndex) * weight; |
|
rainIntensity += GetCurveValue (profile.weather.weatherRainIntensityCurve, profile.weather.weatherRainIntensityCurveIndex) * weight; |
|
snowIntensity += GetCurveValue (profile.weather.weatherSnowIntensityCurve, profile.weather.weatherSnowIntensityCurveIndex) * weight; |
|
windSpeed += GetCurveValue (profile.weather.weatherWindSpeedCurve, profile.weather.weatherWindSpeedCurveIndex) * weight; |
|
windDirection += GetCurveValue (profile.weather.weatherWindDirectionCurve, profile.weather.weatherWindDirectionCurveIndex) * weight; |
|
rainLightVolume += profile.weather.weatherRainLightVolume * weight; |
|
rainMediumVolume += profile.weather.weatherRainMediumVolume * weight; |
|
rainHeavyVolume += profile.weather.weatherRainHeavyVolume * weight; |
|
windLightVolume += profile.weather.weatherWindLightVolume * weight; |
|
windMediumVolume += profile.weather.weatherWindMediumVolume * weight; |
|
windHeavyVolume += profile.weather.weatherWindHeavyVolume * weight; |
|
} |
|
|
|
if (options.keepWeatherUpdate) |
|
{ |
|
wetness += GetCurveValue (profile.weather.weatherWetnessCurve, profile.weather.weatherWetnessCurveIndex) * weight; |
|
snowAmount += GetCurveValue (profile.weather.weatherSnowAmountCurve, profile.weather.weatherSnowAmountCurveIndex) * weight; |
|
covarage += GetCurveValue (profile.weather.weatherCovarageCurve, profile.weather.weatherCovarageCurveIndex) * weight; |
|
outputColor1 += GetGradientValue (profile.weather.weatherOutputColor1GradientColor, profile.weather.weatherOutputColor1Index) * weight; |
|
outputColor2 += GetGradientValue (profile.weather.weatherOutputColor2GradientColor, profile.weather.weatherOutputColor2Index) * weight; |
|
outputColor3 += GetGradientValue (profile.weather.weatherOutputColor3GradientColor, profile.weather.weatherOutputColor3Index) * weight; |
|
} |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// Updates the profiles and calendar days. |
|
/// </summary> |
|
public void UpdateProfiles () |
|
{ |
|
timeOfDay.UpdateCalendar (timeOfDay.selectableDayList); |
|
calendarDayProfile = GetCalendarDayProfile (); |
|
nextCalendarDayProfile = GetNextCalendarDayProfile(); |
|
|
|
if (weatherNumber == 0) |
|
{ |
|
currentDayProfile = calendarDayProfile; |
|
if (!isBlendingWeathers) |
|
{ |
|
sourceWeatherProfile = calendarDayProfile; |
|
} |
|
} |
|
} |
|
|
|
//Start and Stop Sound Effects. |
|
private void SoundPlayController(float volume, AudioSource sound) |
|
{ |
|
sound.volume = volume; |
|
if (volume > 0) |
|
{ |
|
if (!sound.isPlaying) sound.Play (); |
|
} |
|
else if (sound.isPlaying) sound.Stop (); |
|
} |
|
|
|
//It Needs to be Updated Only Once When the Scene Starts. |
|
private void InitializeShaderUniforms () |
|
{ |
|
Shader.SetGlobalTexture (Uniforms._SunTexture, sunTexture); |
|
Shader.SetGlobalTexture (Uniforms._MoonTexture, moonTexture); |
|
Shader.SetGlobalTexture (Uniforms._CloudNoise, cloudNoise); |
|
if (!isBlendingWeathers) |
|
{ |
|
SetStaticCloudTexture(currentDayProfile.clouds.staticCloudTexture, currentDayProfile.clouds.staticCloudTexture); |
|
} |
|
Shader.SetGlobalTexture (Uniforms._StarfieldTexture, starfieldTexture); |
|
Shader.SetGlobalTexture (Uniforms._StarNoiseTexture, starNoiseTexture); |
|
Shader.SetGlobalVector (Uniforms._MieG, new Vector3(0.4375f, 1.5625f, 1.5f)); |
|
Shader.SetGlobalFloat (Uniforms._Pi316, 0.0596831f); |
|
Shader.SetGlobalFloat (Uniforms._Pi14, 0.07957747f); |
|
Shader.SetGlobalFloat (Uniforms._Pi, m_pi); |
|
Shader.SetGlobalFloat (Uniforms._LightSpeed, options.lightSpeed); |
|
Shader.SetGlobalFloat (Uniforms._MieDepth, options.mieDepth); |
|
Shader.SetGlobalFloat (Uniforms._SunSize, options.sunSize); |
|
Shader.SetGlobalFloat (Uniforms._MoonSize, options.moonSize); |
|
Shader.SetGlobalInt (Uniforms._SunsetColorMode, options.sunsetColorMode); |
|
} |
|
|
|
//It Needs to be Constantly Updated. |
|
private void UpdateShaderUniforms () |
|
{ |
|
Shader.SetGlobalFloat (Uniforms._Kr, kr); |
|
Shader.SetGlobalFloat (Uniforms._Km, km); |
|
Shader.SetGlobalFloat(Uniforms._Scattering, scattering * 60.0f); |
|
Shader.SetGlobalFloat (Uniforms._NightIntensity, nightIntensity); |
|
Shader.SetGlobalColor (Uniforms._RayleighColor, rayleighColor); |
|
Shader.SetGlobalColor (Uniforms._MieColor, mieColor); |
|
Shader.SetGlobalColor (Uniforms._SunDiskColor, sunDiskColor); |
|
Shader.SetGlobalFloat (Uniforms._SunDiskIntensity, sunDiskIntensity); |
|
Shader.SetGlobalFloat (Uniforms._Exposure, exposure); |
|
Shader.SetGlobalVector (Uniforms._SunDirection, transform.InverseTransformDirection (-sunTransform.transform.forward)); |
|
Shader.SetGlobalVector (Uniforms._MoonDirection, transform.InverseTransformDirection (- moonTransform.transform.forward)); |
|
switch (options.wavelengthMode) |
|
{ |
|
case 0: |
|
Shader.SetGlobalVector (Uniforms._Br, new Vector3(0.00519673f, 0.0121427f, 0.0296453f) * rayleigh); |
|
Shader.SetGlobalVector (Uniforms._Bm, new Vector3(0.005721017f, 0.004451339f, 0.003146905f) * mie); |
|
break; |
|
case 1: |
|
Shader.SetGlobalVector (Uniforms._Br, GetBetaRay() * rayleigh); |
|
Shader.SetGlobalVector (Uniforms._Bm, GetBetaMie() * mie); |
|
break; |
|
} |
|
|
|
Shader.SetGlobalColor (Uniforms._MoonColor, moonColor); |
|
Shader.SetGlobalColor (Uniforms._MoonBrightColor, moonBrightColor); |
|
Shader.SetGlobalFloat (Uniforms._MoonBrightRange, moonBrightRange); |
|
Shader.SetGlobalFloat (Uniforms._MoonEmission, moonEmission); |
|
Shader.SetGlobalMatrix (Uniforms._MoonMatrix, moonTransform.transform.worldToLocalMatrix); |
|
Shader.SetGlobalVector (Uniforms._StarfieldColorBalance, options.starfieldColor); |
|
Shader.SetGlobalFloat (Uniforms._StarfieldIntensity, starfieldIntensity); |
|
Shader.SetGlobalFloat (Uniforms._MilkyWayIntensity, milkyWayIntensity); |
|
Shader.SetGlobalMatrix (Uniforms._NoiseMatrix, m_noiseMatrix); |
|
|
|
Shader.SetGlobalFloat (Uniforms._FogScale, fogScale); |
|
Shader.SetGlobalFloat (Uniforms._FogBlend, fogBlend); |
|
Shader.SetGlobalFloat(Uniforms._FogDensity, fogDensity); |
|
Shader.SetGlobalFloat (Uniforms._FogDistance, fogDistance); |
|
Shader.SetGlobalFloat (Uniforms._HeightFogBlend, heightFogBlend); |
|
Shader.SetGlobalFloat (Uniforms._HeightFogDensity, heightFogDensity); |
|
Shader.SetGlobalFloat (Uniforms._HeightFogDistance, heightFogDistance); |
|
Shader.SetGlobalFloat (Uniforms._HeightFogStart, options.planetRadius + heightFogStart); |
|
Shader.SetGlobalFloat (Uniforms._HeightFogEnd, options.planetRadius + heightFogEnd); |
|
|
|
//TODO Cloud Layers. |
|
switch (options.cloudMode) |
|
{ |
|
case 1: |
|
Shader.SetGlobalFloat (Uniforms._DynamicCloudLayer1Altitude, dynamicCloudLayer1Altitude); |
|
Shader.SetGlobalFloat (Uniforms._DynamicCloudLayer1Direction, dynamicCloudLayer1Direction); |
|
Shader.SetGlobalFloat (Uniforms._DynamicCloudLayer1Speed, dynamicCloudLayer1Speed); |
|
Shader.SetGlobalFloat (Uniforms._DynamicCloudLayer1Density, Mathf.Lerp (25.0f, 0.0f, dynamicCloudLayer1Density)); |
|
Shader.SetGlobalColor (Uniforms._DynamicCloudLayer1Color1, dynamicCloudLayer1Color1); |
|
Shader.SetGlobalColor (Uniforms._DynamicCloudLayer1Color2, dynamicCloudLayer1Color2); |
|
break; |
|
|
|
case 2: |
|
Shader.SetGlobalColor(Uniforms._StaticCloudColor, staticCloudColor); |
|
Shader.SetGlobalFloat(Uniforms._StaticCloudScattering, staticCloudScattering); |
|
Shader.SetGlobalFloat(Uniforms._StaticCloudExtinction, staticCloudExtinction); |
|
Shader.SetGlobalFloat(Uniforms._StaticCloudPower, staticCloudPower); |
|
Shader.SetGlobalFloat(Uniforms._StaticCloudIntensity, staticCloudIntensity); |
|
Shader.SetGlobalFloat(Uniforms._StaticCloudRotationSpeed, m_cloudRotationSpeed); |
|
break; |
|
} |
|
|
|
if (options.particlesMode == 1) |
|
{ |
|
rainColor.a = 0.5f; |
|
snowColor.a = 0.5f; |
|
rainMaterial.SetColor (Uniforms._RainColor, rainColor); |
|
snowMaterial.SetColor (Uniforms._SnowColor, snowColor); |
|
} |
|
} |
|
|
|
private void SetStaticCloudTexture(Texture2D source, Texture2D destination) |
|
{ |
|
Shader.SetGlobalTexture(Uniforms._StaticCloudTextureSource, source); |
|
Shader.SetGlobalTexture(Uniforms._StaticCloudTextureDestination, destination); |
|
} |
|
|
|
/// <summary> |
|
/// Configure the sky material with its appropriate shader. |
|
/// </summary> |
|
public void ConfigureShaders () |
|
{ |
|
switch (options.shaderMode) |
|
{ |
|
case 0://Pixel Shader. |
|
skydome.gameObject.SetActive (false); |
|
RenderSettings.skybox = skyMaterial; |
|
Shader.SetGlobalInt (Uniforms._CullMode, 2); |
|
switch (options.cloudMode) |
|
{ |
|
case 0: |
|
skyMaterial.shader = Shader.Find ("Azure[Sky]/Pixel Sky"); |
|
break; |
|
|
|
case 1: |
|
skyMaterial.shader = Shader.Find ("Azure[Sky]/Pixel Dynamic Cloud"); |
|
break; |
|
|
|
case 2: |
|
skyMaterial.shader = Shader.Find("Azure[Sky]/Pixel Static Cloud"); |
|
break; |
|
} |
|
break; |
|
case 1://Vertex Shader. |
|
skydome.gameObject.SetActive (true); |
|
RenderSettings.skybox = null; |
|
Shader.SetGlobalInt (Uniforms._CullMode, 1); |
|
switch (options.cloudMode) |
|
{ |
|
case 0: |
|
skyMaterial.shader = Shader.Find ("Azure[Sky]/Vertex Sky"); |
|
break; |
|
|
|
case 1: |
|
skyMaterial.shader = Shader.Find ("Azure[Sky]/Vertex Dynamic Cloud"); |
|
break; |
|
|
|
case 2: |
|
skyMaterial.shader = Shader.Find ("Azure[Sky]/Vertex Static Cloud"); |
|
break; |
|
} |
|
break; |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// Activates/Deactivates the Particles. |
|
/// </summary> |
|
/// <param name="value">Value.</param> |
|
public void SetParticlesActive (bool value) |
|
{ |
|
if (rainParticle) rainParticle.gameObject.SetActive (value); |
|
if (snowParticle) snowParticle.gameObject.SetActive (value); |
|
} |
|
|
|
/// <summary> |
|
/// Activates/Deactivates the Particles. |
|
/// </summary> |
|
/// <param name="value">Value.</param> |
|
public void SetParticlesActive (int value) |
|
{ |
|
bool isTrue = value != 0; |
|
if (rainParticle) rainParticle.gameObject.SetActive (isTrue); |
|
if (snowParticle) snowParticle.gameObject.SetActive (isTrue); |
|
} |
|
} |
|
} |