public void UpdateShaderVariables(Camera camera, Material lookupMaterial, ComputeShader lookupComputeShader)
{
UpdateShaderVariables(camera);
WeatherMakerCelestialObjectScript sun = WeatherMakerLightManagerScript.Instance.SunPerspective;
if (sun == null)
{
return;
}
bool disableAtmosphericScattering = (WeatherMakerScript.Instance == null || WeatherMakerScript.Instance.PerformanceProfile == null ||
WeatherMakerScript.Instance.PerformanceProfile.AtmosphereQuality == WeatherMakerAtmosphereQuality.Disabled ||
WeatherMakerLightManagerScript.Instance == null || WeatherMakerLightManagerScript.Instance.SunPerspective == null ||
WeatherMakerCommandBufferManagerScript.Instance == null || camera == null || lookupMaterial == null || lookupComputeShader == null ||
!SystemInfo.supportsComputeShaders || (camera != null && camera.stereoEnabled));
UpdateShaderTextures();
UpdatePrecomputedTextures(lookupMaterial, lookupComputeShader);
if (UpdateSunColor)
{
UpdateDirectionalLightColor(sun, ComputeLightColor(sun.Light));
}
if (UpdateAmbientColor)
{
UpdateAmbientLightColor(ComputeAmbientColor(sun.Light));
}
if (!disableAtmosphericScattering)
{
UpdateInscatteringLUT(lookupComputeShader, sun.Light, camera);
}
}
private void UpdateDirectionalLightColor(WeatherMakerCelestialObjectScript light, Color c)
{
Vector3 color = new Vector3(c.r, c.g, c.b);
float length = color.magnitude;
color /= length;
light.LightColor = new Color(Mathf.Max(color.x, 0.01f), Mathf.Max(color.y, 0.01f), Mathf.Max(color.z, 0.01f), 1.0f);
}
private void RaycastForEclipse(Camera camera, Material material)
{
if (WeatherMakerLightManagerScript.Instance == null)
{
return;
}
// disable allow eclipses everywhere by default
float eclipsePower = 0.0f;
foreach (WeatherMakerCelestialObjectScript moon in WeatherMakerLightManagerScript.Instance.Moons)
{
Shader.SetGlobalInt(WMS._WeatherMakerSkyEnableSunEclipse, 0);
if (moon.Collider != null)
{
moon.Collider.enabled = CheckForEclipse;
}
}
if (CheckForEclipse)
{
WeatherMakerCelestialObjectScript sun = WeatherMakerLightManagerScript.SunForCamera(camera);
if (sun != null)
{
float sunRadius = Mathf.Lerp(0.0f, 1000.0f, Mathf.Pow(sun.Scale, 0.15f));
Vector3 origin = camera.transform.position - (sun.transform.forward * camera.farClipPlane * 1.7f);
int hitCount = Physics.SphereCastNonAlloc(origin, sunRadius, sun.transform.forward, eclipseHits, camera.farClipPlane);
for (int i = 0; i < hitCount; i++)
{
foreach (WeatherMakerCelestialObjectScript moon in WeatherMakerLightManagerScript.Instance.Moons)
{
if (moon != null && moon.transform.gameObject == eclipseHits[i].collider.gameObject)
{
float dot = Mathf.Abs(Vector3.Dot(eclipseHits[i].normal, sun.transform.forward));
eclipsePower += Mathf.Pow(dot, 256.0f);
Shader.SetGlobalInt(WMS._WeatherMakerSkyEnableSunEclipse, 1);
//Debug.LogFormat("Eclipse raycast normal: {0}, dot: {1}, power: {2}", eclipseHits[i].normal, dot, eclipsePower);
break;
}
}
}
}
}
if (eclipsePower == 0.0f)
{
WeatherMakerLightManagerScript.Instance.DirectionalLightIntensityMultipliers["WeatherMakerSkySphereScriptEclipse"] = 1.0f;
}
else
{
float eclipseLightReducer = 1.0f - Mathf.Clamp(eclipsePower, 0.0f, 1.0f);
WeatherMakerLightManagerScript.Instance.DirectionalLightIntensityMultipliers["WeatherMakerSkySphereScriptEclipse"] = eclipseLightReducer;
Shader.SetGlobalFloat(WMS._NightSkyMultiplier, Mathf.Max(1.0f - Mathf.Min(1.0f, AtmosphereProfile.AtmosphereThickness), Mathf.Max(eclipsePower, WeatherMakerDayNightCycleManagerScript.Instance.NightMultiplier)));
}
}
private void UpdateUnityFog(Camera camera)
{
if (!UseUnityFog)
{
return;
}
WeatherMakerCelestialObjectScript sun = WeatherMakerLightManagerScript.SunForCamera(camera);
if (sun == null)
{
return;
}
RenderSettings.fog = (FogProfile.fogDensity > 0.0001f && FogProfile.FogMode != WeatherMakerFogMode.None);
Color fogColor = (FogProfile.FogColor * (sun == null || !sun.LightIsOn ? Color.black : sun.GetGradientColor(FogProfile.FogGradientColor)));
if (WeatherMakerLightManagerScript.Instance != null)
{
bool cameraIsPerspective = (camera == null || !camera.orthographic);
foreach (WeatherMakerLightManagerScript.LightState light in WeatherMakerLightManagerScript.Instance.Lights)
{
if (light.Light.type == LightType.Directional && light.Light != sun.Light)
{
WeatherMakerCelestialObjectScript obj = light.Light.GetComponent <WeatherMakerCelestialObjectScript>();
if (obj != null && obj.OrbitTypeIsPerspective == cameraIsPerspective)
{
fogColor += (FogProfile.FogColor * (light.Light.color * light.Light.intensity));
}
break;
}
}
}
RenderSettings.fogColor = fogColor;
RenderSettings.fogDensity = FogProfile.fogDensity;
switch (FogProfile.FogMode)
{
case WeatherMakerFogMode.Constant:
case WeatherMakerFogMode.Linear:
RenderSettings.fogMode = FogMode.Linear;
break;
case WeatherMakerFogMode.None:
RenderSettings.fogDensity = 0.0f;
break;
case WeatherMakerFogMode.Exponential:
RenderSettings.fogMode = FogMode.Exponential;
break;
case WeatherMakerFogMode.ExponentialSquared:
RenderSettings.fogMode = FogMode.ExponentialSquared;
break;
}
}
private static float GetTotalSunIntensity(WeatherMakerCelestialObjectScript sun)
{
// earth shadow hack
const float cutoffAngle = 1.67510731556870734f;// Mathf.PI / 1.95f;
const float steepness = 1.5f;
const float EE = 1000.0f;
Vector3 sunDir = sun.transform.forward;
float zenithAngleCos = Vector3.Dot(sunDir, Vector3.up);
return(Mathf.Max(0.5f, EE * Mathf.Max(0.0f, 1.0f - Mathf.Exp(-((cutoffAngle - Mathf.Acos(zenithAngleCos)) / steepness)))));
}
private void SetShaderSkyParameters(Camera camera, Material material, WeatherMakerCelestialObjectScript sun)
{
Shader.SetGlobalInt(WMS._WeatherMakerSkyRenderType, (int)SkyMode);
Shader.SetGlobalTexture(WMS._DayTex, DayTexture);
Shader.SetGlobalTexture(WMS._DawnDuskTex, DawnDuskTexture);
Shader.SetGlobalTexture(WMS._NightTex, NightTexture);
SetGlobalSkyParameters(SkyGradient, SkyGroundGradient, AtmosphereProfile.MieG, AtmosphereProfile.MieScatterCoefficient, AtmosphereProfile.RayleighScatterCoefficient,
AtmosphereProfile.AtmosphereThickness, AtmosphereProfile.AtmosphereTurbidity,
SkyExposure, SkyTintColor, SkyOuterRadius, SkyInnerRadius, camera.transform.position.y, LightWaveLengths,
sun);
bool gamma = (QualitySettings.activeColorSpace == ColorSpace.Gamma);
Shader.SetGlobalFloat(WMS._WeatherMakerSkyDitherLevel, (gamma ? DitherLevel : DitherLevel * 0.5f));
Shader.SetGlobalFloat(WMS._WeatherMakerSkyYOffset2D, YOffsetMultiplier);
Shader.SetGlobalVector(WMS._WeatherMakerSkyFade, new Vector4(SkyDepthFadeStart, (SkyDepthFadeStart >= 1.0f ? 0.0f : 1.0f / (1.0f - SkyDepthFadeStart)), SkyCameraHeightFadeMultiplier, 0.0f));
}
/// <summary>
/// Update a fog material with fog properties from this object
/// </summary>
/// <param name="material">Fog material</param>
/// <param name="camera">Camera</param>
/// <param name="global">Whether to set global shader properties</param>
public virtual void UpdateMaterialProperties(Material material, Camera camera, bool global)
{
WeatherMakerCelestialObjectScript sun = WeatherMakerLightManagerScript.SunForCamera(camera);
if (sun == null)
{
return;
}
fogLightAbsorption = (FogLightAbsorption == null ? 0.4f : sun.GetGradientColor(FogLightAbsorption).a);
bool gamma = (QualitySettings.activeColorSpace == ColorSpace.Gamma);
float scatterCover = (WeatherMakerFullScreenCloudsScript.Instance != null && WeatherMakerFullScreenCloudsScript.Instance.enabled && WeatherMakerFullScreenCloudsScript.Instance.CloudProfile != null ? WeatherMakerFullScreenCloudsScript.Instance.CloudProfile.CloudCoverTotal : 0.0f);
scatterCover = Mathf.Pow(scatterCover, 4.0f);
Color fogEmissionColor = FogEmissionColor * FogEmissionColor.a;
fogEmissionColor.a = FogEmissionColor.a;
float fogNoiseSampleCount = (float)(WeatherMakerScript.Instance == null ? FogNoiseSampleCount : WeatherMakerScript.Instance.PerformanceProfile.FogNoiseSampleCount);
float invFogNoiseSampleCount = 1.0f / fogNoiseSampleCount;
int hasNoiseInt = (HasNoise ? 1 : 0);
float ditherLevel = (gamma ? DitherLevel : DitherLevel * 0.5f);
Color fogDensityColor = sun.GetGradientColor(FogDensityGradient);
fogDensity = FogDensity * fogDensityColor.a;
if (!(this is WeatherMakerFullScreenFogProfileScript) || FogMode == WeatherMakerFogMode.None || fogDensity <= 0.0f || MaxFogFactor <= 0.001f)
{
fogScatterReduction = 1.0f;
}
else if (FogMode == WeatherMakerFogMode.Exponential)
{
fogScatterReduction = Mathf.Clamp(1.0f - ((fogDensity + scatterCover) * 0.5f), 0.15f, 1.0f);
}
else if (FogMode == WeatherMakerFogMode.Linear)
{
fogScatterReduction = Mathf.Clamp((1.0f - ((fogDensity + scatterCover) * 0.25f)), 0.15f, 1.0f);
}
else if (FogMode == WeatherMakerFogMode.ExponentialSquared)
{
fogScatterReduction = Mathf.Clamp((1.0f - ((fogDensity + scatterCover) * 0.75f)), 0.15f, 1.0f);
}
else if (FogMode == WeatherMakerFogMode.Constant)
{
fogScatterReduction = Mathf.Clamp(1.0f - (fogDensity + scatterCover), 0.5f, 1.0f);
}
if (global)
{
Shader.SetGlobalFloat(WMS._WeatherMakerFogDensityScatter, fogScatterReduction);
Shader.SetGlobalInt(WMS._WeatherMakerFogNoiseEnabled, hasNoiseInt);
}
else
{
material.SetFloat(WMS._WeatherMakerFogDensityScatter, fogScatterReduction);
material.SetInt(WMS._WeatherMakerFogNoiseEnabled, hasNoiseInt);
}
if (WeatherMakerScript.Instance == null || WeatherMakerScript.Instance.PerformanceProfile.EnableFogLights)
{
float fogShadowSampleCount = (float)(WeatherMakerScript.Instance == null ? FogShadowSampleCount : WeatherMakerScript.Instance.PerformanceProfile.FogShadowSampleCount);
float brightness = Mathf.Min(sun.Light.intensity, Mathf.Pow(sun.Light.intensity, 2.0f));
if (QualitySettings.shadows != ShadowQuality.Disable &&
fogShadowSampleCount > 0 &&
sun.Light.intensity > 0.0f &&
sun.Light.shadows != LightShadows.None &&
FogShadowMaxRayLength > 0.0f &&
brightness > 0.0f)
{
float invFogShadowSampleCount = 1.0f / fogShadowSampleCount;
float fogShadowBrightness = brightness * FogShadowBrightness;
if (global)
{
Shader.SetGlobalInt(WMS._WeatherMakerFogVolumetricLightMode, 2);
Shader.SetGlobalFloat(WMS._WeatherMakerFogLightShadowSampleCount, fogShadowSampleCount);
Shader.SetGlobalFloat(WMS._WeatherMakerFogLightShadowInvSampleCount, invFogShadowSampleCount);
Shader.SetGlobalFloat(WMS._WeatherMakerFogLightShadowMaxRayLength, FogShadowMaxRayLength);
Shader.SetGlobalFloat(WMS._WeatherMakerFogLightShadowMultiplier, FogShadowMultiplier);
Shader.SetGlobalFloat(WMS._WeatherMakerFogLightShadowPower, FogShadowPower);
Shader.SetGlobalFloat(WMS._WeatherMakerFogLightShadowBrightness, fogShadowBrightness);
Shader.SetGlobalFloat(WMS._WeatherMakerFogLightShadowDecay, FogShadowDecay);
Shader.SetGlobalFloat(WMS._WeatherMakerFogLightShadowDither, FogShadowDither);
Shader.SetGlobalVector(WMS._WeatherMakerFogLightShadowDitherMagic, FogShadowDitherMagic);
Shader.SetGlobalFloat(WMS._WeatherMakerFogCloudShadowStrength, FogCloudShadowStrength);
}
else
{
material.SetInt(WMS._WeatherMakerFogVolumetricLightMode, 2);
material.SetFloat(WMS._WeatherMakerFogLightShadowSampleCount, fogShadowSampleCount);
material.SetFloat(WMS._WeatherMakerFogLightShadowInvSampleCount, invFogShadowSampleCount);
material.SetFloat(WMS._WeatherMakerFogLightShadowMaxRayLength, FogShadowMaxRayLength);
material.SetFloat(WMS._WeatherMakerFogLightShadowMultiplier, FogShadowMultiplier);
material.SetFloat(WMS._WeatherMakerFogLightShadowPower, FogShadowPower);
material.SetFloat(WMS._WeatherMakerFogLightShadowBrightness, fogShadowBrightness);
material.SetFloat(WMS._WeatherMakerFogLightShadowDecay, FogShadowDecay);
material.SetFloat(WMS._WeatherMakerFogLightShadowDither, FogShadowDither);
material.SetVector(WMS._WeatherMakerFogLightShadowDitherMagic, FogShadowDitherMagic);
material.SetFloat(WMS._WeatherMakerFogCloudShadowStrength, FogCloudShadowStrength);
}
}
else
{
if (global)
{
Shader.SetGlobalInt(WMS._WeatherMakerFogVolumetricLightMode, 1);
}
else
{
material.SetInt(WMS._WeatherMakerFogVolumetricLightMode, 1);
}
}
}
else
{
if (global)
{
Shader.SetGlobalInt(WMS._WeatherMakerFogVolumetricLightMode, 0);
}
else
{
material.SetInt(WMS._WeatherMakerFogVolumetricLightMode, 0);
}
}
Color fogColor = sun.GetGradientColor(FogGradientColor) * FogColor;
FogEndDepth = Mathf.Max(FogStartDepth, FogEndDepth);
float endDepth = (FogEndDepth <= FogStartDepth ? FogStartDepth + 5000.0f : FogEndDepth);
float fogLinearFogFactor = 0.1f * (1.0f / Mathf.Max(0.0001f, (endDepth - FogStartDepth))) * fogDensity * (endDepth - FogStartDepth);
if (global)
{
Shader.SetGlobalFloat(WMS._WeatherMakerFogStartDepth, FogStartDepth);
Shader.SetGlobalFloat(WMS._WeatherMakerFogEndDepth, endDepth);
Shader.SetGlobalColor(WMS._WeatherMakerFogColor, fogColor);
Shader.SetGlobalColor(WMS._WeatherMakerFogEmissionColor, fogEmissionColor);
Shader.SetGlobalFloat(WMS._WeatherMakerFogHeightFalloffPower, FogHeightFalloffPower);
Shader.SetGlobalFloat(WMS._WeatherMakerFogLightAbsorption, fogLightAbsorption);
Shader.SetGlobalFloat(WMS._WeatherMakerFogLinearFogFactor, fogLinearFogFactor);
Shader.SetGlobalFloat(WMS._WeatherMakerFogNoisePercent, fogNoisePercent);
Shader.SetGlobalFloat(WMS._WeatherMakerFogNoiseScale, FogNoiseScale);
Shader.SetGlobalFloat(WMS._WeatherMakerFogNoiseAdder, FogNoiseAdder);
Shader.SetGlobalFloat(WMS._WeatherMakerFogNoiseMultiplier, FogNoiseMultiplier);
Shader.SetGlobalVector(WMS._WeatherMakerFogNoiseVelocity, fogNoiseVelocityAccum);
Shader.SetGlobalFloat(WMS._WeatherMakerFogNoiseSampleCount, fogNoiseSampleCount);
Shader.SetGlobalFloat(WMS._WeatherMakerFogNoiseSampleCountInverse, invFogNoiseSampleCount);
Shader.SetGlobalVector(WMS._WeatherMakerFogNoisePositionOffset, fogNoisePositionOffset);
Shader.SetGlobalFloat(WMS._WeatherMakerFogFactorMax, MaxFogFactor);
Shader.SetGlobalInt(WMS._WeatherMakerFogMode, (int)FogMode);
Shader.SetGlobalFloat(WMS._WeatherMakerFogDitherLevel, ditherLevel);
Shader.SetGlobalFloat(WMS._WeatherMakerFogDensity, fogDensity);
Shader.SetGlobalFloat(WMS._WeatherMakerFogFactorMultiplier, FogFactorMultiplier);
}
else
{
material.SetFloat(WMS._WeatherMakerFogStartDepth, FogStartDepth);
material.SetFloat(WMS._WeatherMakerFogEndDepth, endDepth);
material.SetColor(WMS._WeatherMakerFogColor, fogColor);
material.SetColor(WMS._WeatherMakerFogEmissionColor, fogEmissionColor);
material.SetFloat(WMS._WeatherMakerFogHeightFalloffPower, FogHeightFalloffPower);
material.SetFloat(WMS._WeatherMakerFogLightAbsorption, fogLightAbsorption);
material.SetFloat(WMS._WeatherMakerFogLinearFogFactor, fogLinearFogFactor);
material.SetFloat(WMS._WeatherMakerFogNoisePercent, fogNoisePercent);
material.SetFloat(WMS._WeatherMakerFogNoiseScale, FogNoiseScale);
material.SetFloat(WMS._WeatherMakerFogNoiseAdder, FogNoiseAdder);
material.SetFloat(WMS._WeatherMakerFogNoiseMultiplier, FogNoiseMultiplier);
material.SetVector(WMS._WeatherMakerFogNoiseVelocity, fogNoiseVelocityAccum);
material.SetFloat(WMS._WeatherMakerFogNoiseSampleCount, fogNoiseSampleCount);
material.SetFloat(WMS._WeatherMakerFogNoiseSampleCountInverse, invFogNoiseSampleCount);
material.SetVector(WMS._WeatherMakerFogNoisePositionOffset, fogNoisePositionOffset);
material.SetFloat(WMS._WeatherMakerFogFactorMax, MaxFogFactor);
material.SetInt(WMS._WeatherMakerFogMode, (int)FogMode);
material.SetFloat(WMS._WeatherMakerFogDitherLevel, ditherLevel);
material.SetFloat(WMS._WeatherMakerFogDensity, fogDensity);
material.SetFloat(WMS._WeatherMakerFogFactorMultiplier, FogFactorMultiplier);
}
}
/// <summary>
/// Perform updates to the sky plane based on profile settings
/// </summary>
/// <param name="camera">Current camera</param>
/// <param name="material">Sky sphere material</param>
/// <param name="skyPlane">Sky plane game object</param>
/// <param name="sun">The sun</param>
public void UpdateSkyPlane(Camera camera, Material material, GameObject skyPlane, WeatherMakerCelestialObjectScript sun)
{
if (material == null || WeatherMakerLightManagerScript.Instance == null || sun == null)
{
return;
}
SetSkyPlaneScalesAndPositions(camera, skyPlane);
SetShaderLightParameters(material);
SetShaderSkyParameters(camera, material, sun);
shaderProps = (shaderProps ?? new WeatherMakerShaderPropertiesScript(material));
shaderProps.Update(material);
//WeatherMakerLightManagerScript.Instance.UpdateShaderVariables(camera, shaderProps, null);
}
/// <summary>
/// Perform updates to the sky sphere based on profile settings
/// </summary>
/// <param name="camera">Current camera</param>
/// <param name="material">Sky sphere material</param>
/// <param name="skySphere">Sky sphere game object</param>
/// <param name="sun">The sun</param>
public void UpdateSkySphere(Camera camera, Material material, GameObject skySphere, WeatherMakerCelestialObjectScript sun)
{
if (material == null || WeatherMakerLightManagerScript.Instance == null || sun == null)
{
return;
}
if (!SystemInfo.supportsComputeShaders)
{
if (SkyMode == WeatherMakeSkyMode.ProceduralPhysicallyBased)
{
SkyMode = WeatherMakeSkyMode.ProceduralUnityStyle;
}
else if (SkyMode == WeatherMakeSkyMode.ProceduralTexturedPhysicallyBased)
{
SkyMode = WeatherMakeSkyMode.ProceduralTexturedUnityStyle;
}
}
SetSkySphereScalesAndPositions(camera, skySphere);
SetShaderLightParameters(material);
RaycastForEclipse(camera, material);
SetShaderSkyParameters(camera, material, sun);
shaderProps = (shaderProps ?? new WeatherMakerShaderPropertiesScript(material));
shaderProps.Update(material);
//WeatherMakerLightManagerScript.Instance.UpdateShaderVariables(camera, shaderProps, null);
}
internal static void SetGlobalSkyParameters(Gradient skyGradient, Gradient skyGroundGradient, float skyAtmosphereMie, float skyMieMultiplier, float skyRayleighMultiplier, float skyAtmosphereThickness,
float skyAtmosphereTurbidity, float skyExposure, Color skyTintColor, float skyOuterRadius, float skyInnerRadius, float skyCameraHeight, Vector4 waveLength,
WeatherMakerCelestialObjectScript sun)
{
if (sun == null)
{
return;
}
// global sky parameters
float mieG = -skyAtmosphereMie;
float mieG2 = mieG * mieG;
float mieConstant = 0.001f * skyMieMultiplier;
float rayleighConstant = 0.0025f * skyRayleighMultiplier;
rayleighConstant = Mathf.LerpUnclamped(0.0f, rayleighConstant, Mathf.Pow(skyAtmosphereThickness, 2.5f));
float redColor = waveLength.x;
float greenColor = waveLength.y;
float blueColor = waveLength.z;
float lightRange = waveLength.w;
float lightWaveLengthRedTint = Mathf.Lerp(redColor - lightRange, redColor + lightRange, 1.0f - skyTintColor.r);
float lightWaveLengthGreenTint = Mathf.Lerp(greenColor - lightRange, greenColor + lightRange, 1.0f - skyTintColor.g);
float lightWaveLengthBlueTint = Mathf.Lerp(blueColor - lightRange, blueColor + lightRange, 1.0f - skyTintColor.b);
float lightWaveLengthRed4 = lightWaveLengthRedTint * lightWaveLengthRedTint * lightWaveLengthRedTint * lightWaveLengthRedTint;
float lightWaveLengthGreen4 = lightWaveLengthGreenTint * lightWaveLengthGreenTint * lightWaveLengthGreenTint * lightWaveLengthGreenTint;
float lightWaveLengthBlue4 = lightWaveLengthBlueTint * lightWaveLengthBlueTint * lightWaveLengthBlueTint * lightWaveLengthBlueTint;
float lightInverseWaveLengthRed4 = 1.0f / lightWaveLengthRed4;
float lightInverseWaveLengthGreen4 = 1.0f / lightWaveLengthGreen4;
float lightInverseWaveLengthBlue4 = 1.0f / lightWaveLengthBlue4;
const float sunBrightnessFactor = 40.0f;
float sunRed = rayleighConstant * sunBrightnessFactor * lightInverseWaveLengthRed4;
float sunGreen = rayleighConstant * sunBrightnessFactor * lightInverseWaveLengthGreen4;
float sunBlue = rayleighConstant * sunBrightnessFactor * lightInverseWaveLengthBlue4;
float sunIntensity = mieConstant * sunBrightnessFactor;
float pi4Red = rayleighConstant * 4.0f * skyAtmosphereTurbidity * Mathf.PI * lightInverseWaveLengthRed4;
float pi4Green = rayleighConstant * 4.0f * skyAtmosphereTurbidity * Mathf.PI * lightInverseWaveLengthGreen4;
float pi4Blue = rayleighConstant * 4.0f * skyAtmosphereTurbidity * Mathf.PI * lightInverseWaveLengthBlue4;
float pi4Intensity = mieConstant * 4.0f * skyAtmosphereTurbidity * Mathf.PI;
float scaleFactor = 1.0f / (skyOuterRadius - 1.0f);
const float scaleDepth = 0.25f;
float scaleOverScaleDepth = scaleFactor / scaleDepth;
if (sun != null)
{
Vector4 col = sun.GetGradientColor(skyGradient) * skyTintColor;
col *= skyExposure;
Shader.SetGlobalVector(WMS._WeatherMakerSkyTintColor, col);
float mieDot = sun.GetSunMieDot();
Shader.SetGlobalVector(WMS._WeatherMakerSkyMieG, new Vector4(mieG, mieG2, -mieG, mieDot));
col = sun.GetGradientColor(skyGroundGradient);
Shader.SetGlobalVector(WMS._WeatherMakerSkyGroundColor, col);
}
Shader.SetGlobalVector(WMS._WeatherMakerSkyAtmosphereParams, new Vector4(skyAtmosphereThickness, skyAtmosphereTurbidity, skyExposure, 0.0f));
Shader.SetGlobalVector(WMS._WeatherMakerSkyRadius, new Vector4(skyOuterRadius, skyOuterRadius * skyOuterRadius, skyInnerRadius, skyInnerRadius * skyInnerRadius));
Shader.SetGlobalVector(WMS._WeatherMakerSkyMie, new Vector4(1.5f * ((1.0f - mieG2) / (2.0f + mieG2)), 1.0f + mieG2, 2.0f + mieG, 0.0f));
Shader.SetGlobalVector(WMS._WeatherMakerSkyLightScattering, new Vector4(sunRed, sunGreen, sunBlue, sunIntensity));
Shader.SetGlobalVector(WMS._WeatherMakerSkyLightPIScattering, new Vector4(pi4Red, pi4Green, pi4Blue, pi4Intensity));
Shader.SetGlobalVector(WMS._WeatherMakerSkyScale, new Vector4(scaleFactor, scaleDepth, scaleOverScaleDepth, Mathf.Max(0.0f, skyCameraHeight) * 0.000001f));
// reduce wave length for preetham sky formulas
waveLength *= 1E-6f;
Shader.SetGlobalVector(WMS._WeatherMakerSkyTotalRayleigh, GetTotalRayleigh(waveLength, skyRayleighMultiplier * skyAtmosphereThickness, sun));
Shader.SetGlobalVector(WMS._WeatherMakerSkyTotalMie, GetTotalMie(waveLength, skyAtmosphereTurbidity, skyMieMultiplier, sun));
}
private static readonly Vector3 K = new Vector3(0.686f, 0.678f, 0.666f); // coefficient for primaries
private static Vector4 GetTotalMie(Vector3 waveLength, float turbidity, float multiplier, WeatherMakerCelestialObjectScript sun)
{
const float v = 2.0f; // 4 - 2
float sunY = -sun.transform.forward.y;
float mieCoefficient = Mathf.Min(0.99f, 0.005f * multiplier * Mathf.Min(50.0f, 1.0f / Mathf.Pow(Mathf.Max(0.01f, sunY), 0.5f)));
float c = (0.2f * turbidity) * 10E-18f;
float d = 0.434f * c * Mathf.PI;
Vector4 m = new Vector4
(
mieCoefficient * (d * Mathf.Pow((2.0f * Mathf.PI) / waveLength.x, v) * K.x),
mieCoefficient * (d * Mathf.Pow((2.0f * Mathf.PI) / waveLength.y, v) * K.y),
mieCoefficient * (d * Mathf.Pow((2.0f * Mathf.PI) / waveLength.z, v) * K.z),
GetTotalSunIntensity(sun)
);
return(m);
}
private static Vector4 GetTotalRayleigh(Vector3 waveLength, float rayleighMultiplier, WeatherMakerCelestialObjectScript sun)
{
if (sun == null)
{
return(Vector4.one);
}
// https://github.com/ngokevin/kframe/blob/master/components/sun-sky/shaders/fragment.glsl
const float n = 1.0003f; // refractive index of air
const float N = 2.545E25f; // number of molecules per unit volume for air at 288.15K and 1013mb (sea level -45 celsius)
const float pn = 0.035f; // depolatization factor for standard air
float sunPosY = -sun.transform.forward.y;
float sunfade = 1.0f - Mathf.Clamp(1.0f - Mathf.Exp((sunPosY / 450000.0f)), 0.0f, 1.0f);
float rayleighCoefficient = rayleighMultiplier - (1.0f * (1.0f - sunfade));
Vector4 r = new Vector4
(
rayleighCoefficient * (((8.0f * Mathf.Pow(Mathf.PI, 3.0f) * (Mathf.Pow(Mathf.Pow(n, 2.0f) - 1.0f, 2.0f))) * (6.0f + 3.0f * pn)) / ((3.0f * N * Mathf.Pow(waveLength.x, 4.0f)) * (6.0f - 7.0f * pn))),
rayleighCoefficient * (((8.0f * Mathf.Pow(Mathf.PI, 3.0f) * (Mathf.Pow(Mathf.Pow(n, 2.0f) - 1.0f, 2.0f))) * (6.0f + 3.0f * pn)) / ((3.0f * N * Mathf.Pow(waveLength.y, 4.0f)) * (6.0f - 7.0f * pn))),
rayleighCoefficient * (((8.0f * Mathf.Pow(Mathf.PI, 3.0f) * (Mathf.Pow(Mathf.Pow(n, 2.0f) - 1.0f, 2.0f))) * (6.0f + 3.0f * pn)) / ((3.0f * N * Mathf.Pow(waveLength.z, 4.0f)) * (6.0f - 7.0f * pn))),
sunfade
);
return(r);
}
public void SetShaderCloudParameters(Material cloudMaterial, ComputeShader cloudProbe, Camera camera, Texture weatherMap)
{
if (WeatherMakerScript.Instance == null ||
WeatherMakerScript.Instance.PerformanceProfile == null ||
WeatherMakerDayNightCycleManagerScript.Instance == null ||
WeatherMakerLightManagerScript.Instance == null)
{
return;
}
WeatherMakerCelestialObjectScript sun = (camera == null || !camera.orthographic ? WeatherMakerLightManagerScript.Instance.SunPerspective : WeatherMakerLightManagerScript.Instance.SunOrthographic);
if (sun == null)
{
return;
}
if (!isAnimating)
{
CloudLayerVolumetric1.CloudDirLightGradientColorColor = sun.GetGradientColor(CloudLayerVolumetric1.CloudDirLightGradientColor);
CloudLayerVolumetric1.CloudGradientStratusVector = WeatherMakerCloudVolumetricProfileScript.CloudHeightGradientToVector4(CloudLayerVolumetric1.CloudGradientStratus);
CloudLayerVolumetric1.CloudGradientStratoCumulusVector = WeatherMakerCloudVolumetricProfileScript.CloudHeightGradientToVector4(CloudLayerVolumetric1.CloudGradientStratoCumulus);
CloudLayerVolumetric1.CloudGradientCumulusVector = WeatherMakerCloudVolumetricProfileScript.CloudHeightGradientToVector4(CloudLayerVolumetric1.CloudGradientCumulus);
}
shaderProps.Update(null);
SetShaderVolumetricCloudShaderProperties(shaderProps, weatherMap, sun);
if (cloudProbe != null)
{
shaderProps.Update(cloudProbe);
SetShaderVolumetricCloudShaderProperties(shaderProps, weatherMap, sun);
}
Shader.SetGlobalInt(WMS._WeatherMakerCloudVolumetricShadowSampleCount, WeatherMakerScript.Instance.PerformanceProfile.VolumetricCloudShadowSampleCount);
if (CloudsEnabled)
{
float cover = Mathf.Min(1.0f, CloudCoverTotal * (1.5f - CloudLightAbsorptionTotal));
float sunIntensityMultiplier = Mathf.Clamp(1.0f - (cover * CloudLightStrength), 0.2f, 1.0f);
float sunIntensityMultiplierWithoutLightStrength = Mathf.Clamp(1.0f - (cover * cover * 0.85f), 0.2f, 1.0f);
float cloudShadowReducer = sunIntensityMultiplierWithoutLightStrength;
float dirLightMultiplier = sunIntensityMultiplier * Mathf.Lerp(1.0f, DirectionalLightIntensityMultiplier, cover);
Shader.SetGlobalFloat(WMS._WeatherMakerCloudGlobalShadow2, cloudShadowReducer);
CloudGlobalShadow = cloudShadowReducer = Mathf.Min(cloudShadowReducer, Shader.GetGlobalFloat(WMS._WeatherMakerCloudGlobalShadow));
CloudDirectionalLightDirectBlock = dirLightMultiplier;
// if we have shadows turned on, use screen space shadows
if (QualitySettings.shadows != ShadowQuality.Disable && WeatherMakerLightManagerScript.ScreenSpaceShadowMode != UnityEngine.Rendering.BuiltinShaderMode.Disabled &&
WeatherMakerScript.Instance.PerformanceProfile.VolumetricCloudShadowDownsampleScale != WeatherMakerDownsampleScale.Disabled &&
WeatherMakerScript.Instance.PerformanceProfile.VolumetricCloudShadowSampleCount > 0)
{
// do not reduce light intensity or shadows, screen space shadows are being used
WeatherMakerLightManagerScript.Instance.DirectionalLightIntensityMultipliers.Remove("WeatherMakerFullScreenCloudsScript");
Shader.SetGlobalFloat(WMS._WeatherMakerDirLightMultiplier, 1.0f);
Shader.SetGlobalFloat(WMS._WeatherMakerCloudGlobalShadow, 1.0f);
}
else
{
// save dir light multiplier so flat clouds can adjust to the dimmed light
Shader.SetGlobalFloat(WMS._WeatherMakerDirLightMultiplier, 1.0f / Mathf.Max(0.0001f, dirLightMultiplier));
Shader.SetGlobalFloat(WMS._WeatherMakerCloudGlobalShadow, cloudShadowReducer);
// brighten up on orthographic, looks better
if (WeatherMakerScript.Instance.MainCamera != null && WeatherMakerScript.Instance.MainCamera.orthographic)
{
sunIntensityMultiplier = Mathf.Min(1.0f, sunIntensityMultiplier * 2.0f);
}
// we rely on sun intensity reduction to fake shadows
WeatherMakerLightManagerScript.Instance.DirectionalLightIntensityMultipliers["WeatherMakerFullScreenCloudsScript"] = dirLightMultiplier;
}
}
else
{
WeatherMakerLightManagerScript.Instance.DirectionalLightIntensityMultipliers.Remove("WeatherMakerFullScreenCloudsScript");
WeatherMakerLightManagerScript.Instance.DirectionalLightShadowIntensityMultipliers.Remove("WeatherMakerFullScreenCloudsScript");
}
}
private void SetShaderVolumetricCloudShaderProperties(WeatherMakerShaderPropertiesScript props, Texture weatherMap, WeatherMakerCelestialObjectScript sun)
{
props.SetVector(WMS._WeatherMakerCloudCameraPosition, CloudCameraPosition);
props.SetTexture(WMS._WeatherMakerWeatherMapTexture, weatherMap);
props.SetVector(WMS._WeatherMakerWeatherMapScale, new Vector4(WeatherMapScale.x, WeatherMapScale.y, WeatherMapScale.z, 1.0f / WeatherMapScale.z));
props.SetFloat(WMS._CloudCoverVolumetric, CloudLayerVolumetric1.CloudCover.LastValue);
props.SetFloat(WMS._CloudCoverSecondaryVolumetric, CloudLayerVolumetric1.CloudCoverSecondary.LastValue);
props.SetFloat(WMS._CloudTypeVolumetric, CloudLayerVolumetric1.CloudType.LastValue);
props.SetFloat(WMS._CloudTypeSecondaryVolumetric, CloudLayerVolumetric1.CloudTypeSecondary.LastValue);
props.SetFloat(WMS._CloudDensityVolumetric, CloudLayerVolumetric1.CloudDensity.LastValue);
props.SetFloat(WMS._CloudHeightNoisePowerVolumetric, CloudLayerVolumetric1.CloudHeightNoisePowerVolumetric.LastValue);
props.SetInt(WMS._CloudDirLightRaySampleCount, WeatherMakerScript.Instance.PerformanceProfile.VolumetricCloudDirLightRaySampleCount);
props.SetFloat(WMS._CloudPlanetRadiusVolumetric, CloudPlanetRadius);
props.SetFloat(WMS._CloudNoiseScalarVolumetric, CloudLayerVolumetric1.CloudNoiseScalar.LastValue * WeatherMakerScript.Instance.PerformanceProfile.VolumetricCloudNoiseMultiplier);
props.SetTexture(WMS._CloudNoiseShapeVolumetric, CloudLayerVolumetric1.CloudNoiseShape);
props.SetTexture(WMS._CloudNoiseDetailVolumetric, CloudLayerVolumetric1.CloudNoiseDetail);
props.SetTexture(WMS._CloudNoiseCurlVolumetric, CloudLayerVolumetric1.CloudNoiseCurl);
props.SetVector(WMS._CloudShapeAnimationVelocity, CloudLayerVolumetric1.CloudShapeAnimationVelocity);
props.SetVector(WMS._CloudDetailAnimationVelocity, CloudLayerVolumetric1.CloudDetailAnimationVelocity);
props.SetVector(WMS._CloudNoiseScaleVolumetric, CloudLayerVolumetric1.CloudNoiseScale);
props.SetFloat(WMS._CloudNoiseDetailPowerVolumetric, CloudLayerVolumetric1.CloudNoiseDetailPower.LastValue);
props.SetFloat(WMS._CloudShapeNoiseMinVolumetric, CloudLayerVolumetric1.CloudShapeNoiseMin.LastValue);
props.SetFloat(WMS._CloudShapeNoiseMaxVolumetric, CloudLayerVolumetric1.CloudShapeNoiseMax.LastValue);
props.SetFloat(WMS._CloudBottomFadeVolumetric, CloudLayerVolumetric1.CloudBottomFade.LastValue);
props.SetFloat(WMS._WeatherMakerDirectionalLightScatterMultiplier, DirectionalLightScatterMultiplier);
// lower cloud level sphere
// assign global shader so shadow map can see them
props.SetFloat(WMS._CloudStartVolumetric, CloudHeight.LastValue);
props.SetFloat(WMS._CloudStartSquaredVolumetric, CloudHeight.LastValue * CloudHeight.LastValue);
props.SetFloat(WMS._CloudPlanetStartVolumetric, CloudHeight.LastValue + CloudPlanetRadius);
props.SetFloat(WMS._CloudPlanetStartSquaredVolumetric, Mathf.Pow(CloudHeight.LastValue + CloudPlanetRadius, 2.0f));
// height of top minus bottom cloud layer
float height = CloudHeightTop.LastValue - CloudHeight.LastValue;
props.SetFloat(WMS._CloudHeightVolumetric, height);
props.SetFloat(WMS._CloudHeightInverseVolumetric, 1.0f / height);
height *= height;
props.SetFloat(WMS._CloudHeightSquaredVolumetric, height);
props.SetFloat(WMS._CloudHeightSquaredInverseVolumetric, 1.0f / height);
// upper cloud level sphere
props.SetFloat(WMS._CloudEndVolumetric, CloudHeightTop.LastValue);
height = CloudHeightTop.LastValue * CloudHeightTop.LastValue;
props.SetFloat(WMS._CloudEndSquaredVolumetric, height);
props.SetFloat(WMS._CloudEndSquaredInverseVolumetric, 1.0f / height);
props.SetFloat(WMS._CloudPlanetEndVolumetric, CloudHeightTop.LastValue + CloudPlanetRadius);
props.SetFloat(WMS._CloudPlanetEndSquaredVolumetric, Mathf.Pow(CloudHeightTop.LastValue + CloudPlanetRadius, 2.0f));
props.SetFloat(WMS._CloudPlanetRadiusNegativeVolumetric, -CloudPlanetRadius);
props.SetFloat(WMS._CloudPlanetRadiusSquaredVolumetric, CloudPlanetRadius * CloudPlanetRadius);
props.SetVector(WMS._CloudHenyeyGreensteinPhaseVolumetric, CloudLayerVolumetric1.CloudHenyeyGreensteinPhase);
props.SetFloat(WMS._CloudRayOffsetVolumetric, CloudLayerVolumetric1.CloudRayOffset + additionalCloudRayOffset);
props.SetFloat(WMS._CloudMinRayYVolumetric, CloudLayerVolumetric1.CloudMinRayY);
props.SetVector(WMS._CloudGradientStratus, CloudLayerVolumetric1.CloudGradientStratusVector);
props.SetVector(WMS._CloudGradientStratoCumulus, CloudLayerVolumetric1.CloudGradientStratoCumulusVector);
props.SetVector(WMS._CloudGradientCumulus, CloudLayerVolumetric1.CloudGradientCumulusVector);
// flat clouds
float cloudCover1 = 0.0f;
float cloudCover2 = 0.0f;
float cloudCover3 = 0.0f;
float cloudCover4 = 0.0f;
if (isAnimating || CloudLayerVolumetric1 == null || CloudLayerVolumetric1.CloudCover.Maximum == 0.0f || !WeatherMakerScript.Instance.PerformanceProfile.EnableVolumetricClouds ||
(CloudLayerVolumetric1.FlatLayerMask & WeatherMakerVolumetricCloudsFlatLayerMask.One) == WeatherMakerVolumetricCloudsFlatLayerMask.One)
{
cloudCover1 = CloudLayer1.CloudCover;
}
if (isAnimating || CloudLayerVolumetric1 == null || CloudLayerVolumetric1.CloudCover.Maximum == 0.0f || !WeatherMakerScript.Instance.PerformanceProfile.EnableVolumetricClouds ||
(CloudLayerVolumetric1.FlatLayerMask & WeatherMakerVolumetricCloudsFlatLayerMask.Two) == WeatherMakerVolumetricCloudsFlatLayerMask.Two)
{
cloudCover2 = CloudLayer2.CloudCover;
}
if (isAnimating || CloudLayerVolumetric1 == null || CloudLayerVolumetric1.CloudCover.Maximum == 0.0f || !WeatherMakerScript.Instance.PerformanceProfile.EnableVolumetricClouds ||
(CloudLayerVolumetric1.FlatLayerMask & WeatherMakerVolumetricCloudsFlatLayerMask.Three) == WeatherMakerVolumetricCloudsFlatLayerMask.Three)
{
cloudCover3 = CloudLayer3.CloudCover;
}
if (isAnimating || CloudLayerVolumetric1 == null || CloudLayerVolumetric1.CloudCover.Maximum == 0.0f || !WeatherMakerScript.Instance.PerformanceProfile.EnableVolumetricClouds ||
(CloudLayerVolumetric1.FlatLayerMask & WeatherMakerVolumetricCloudsFlatLayerMask.Four) == WeatherMakerVolumetricCloudsFlatLayerMask.Four)
{
cloudCover4 = CloudLayer4.CloudCover;
}
props.SetTexture(WMS._CloudNoise1, CloudLayer1.CloudNoise ?? Texture2D.blackTexture);
props.SetTexture(WMS._CloudNoise2, CloudLayer2.CloudNoise ?? Texture2D.blackTexture);
props.SetTexture(WMS._CloudNoise3, CloudLayer3.CloudNoise ?? Texture2D.blackTexture);
props.SetTexture(WMS._CloudNoise4, CloudLayer4.CloudNoise ?? Texture2D.blackTexture);
props.SetVectorArray(WMS._CloudNoiseScale, CloudLayer1.CloudNoiseScale * scaleReducer, CloudLayer2.CloudNoiseScale * scaleReducer, CloudLayer3.CloudNoiseScale * scaleReducer, CloudLayer4.CloudNoiseScale * scaleReducer);
props.SetVectorArray(WMS._CloudNoiseMultiplier, CloudLayer1.CloudNoiseMultiplier, CloudLayer2.CloudNoiseMultiplier, CloudLayer3.CloudNoiseMultiplier, CloudLayer4.CloudNoiseMultiplier);
props.SetVectorArray(WMS._CloudNoiseVelocity, cloudNoiseVelocityAccum1, cloudNoiseVelocityAccum2, cloudNoiseVelocityAccum3, cloudNoiseVelocityAccum4);
props.SetFloatArrayRotation(WMS._CloudNoiseRotation, CloudLayer1.CloudNoiseRotation.LastValue, CloudLayer2.CloudNoiseRotation.LastValue, CloudLayer3.CloudNoiseRotation.LastValue, CloudLayer4.CloudNoiseRotation.LastValue);
props.SetFloatArray(WMS._CloudHeight, CloudLayer1.CloudHeight, CloudLayer2.CloudHeight, CloudLayer3.CloudHeight, CloudLayer4.CloudHeight);
props.SetFloatArray(WMS._CloudCover, cloudCover1, cloudCover2, cloudCover3, cloudCover4);
props.SetFloatArray(WMS._CloudDensity, CloudLayer1.CloudDensity, CloudLayer2.CloudDensity, CloudLayer3.CloudDensity, CloudLayer4.CloudDensity);
props.SetFloatArray(WMS._CloudSharpness, CloudLayer1.CloudSharpness, CloudLayer2.CloudSharpness, CloudLayer3.CloudSharpness, CloudLayer4.CloudSharpness);
props.SetFloatArray(WMS._CloudRayOffset, CloudLayer1.CloudRayOffset, CloudLayer2.CloudRayOffset, CloudLayer3.CloudRayOffset, CloudLayer4.CloudRayOffset);
props.SetVector(WMS._CloudNoiseSampleCountVolumetric, WeatherMakerScript.Instance.PerformanceProfile.VolumetricCloudSampleCount.ToVector2());
props.SetInt(WMS._CloudRaymarchSkipThreshold, WeatherMakerScript.Instance.PerformanceProfile.VolumetricCloudRaymarchSkipThreshold);
props.SetFloat(WMS._CloudRaymarchMaybeInCloudStepMultiplier, WeatherMakerScript.Instance.PerformanceProfile.VolumetricCloudRaymarchMaybeInCloudStepMultiplier);
props.SetFloat(WMS._CloudRaymarchInCloudStepMultiplier, WeatherMakerScript.Instance.PerformanceProfile.VolumetricCloudRaymarchInCloudStepMultiplier);
props.SetFloat(WMS._CloudRaymarchSkipMultiplier, WeatherMakerScript.Instance.PerformanceProfile.VolumetricCloudRaymarchSkipMultiplier);
props.SetInt(WMS._CloudRaymarchSkipMultiplierMaxCount, WeatherMakerScript.Instance.PerformanceProfile.VolumetricCloudRaymarchSkipMultiplierMaxCount);
props.SetVector(WMS._CloudNoiseLodVolumetric, WeatherMakerScript.Instance.PerformanceProfile.VolumetricCloudLod.ToVector2());
props.SetColor(WMS._CloudColorVolumetric, CloudLayerVolumetric1.CloudColor);
props.SetColor(WMS._CloudDirColorVolumetric, CloudLayerVolumetric1.CloudDirLightGradientColorColor);
props.SetColor(WMS._CloudEmissionColorVolumetric, CloudLayerVolumetric1.CloudEmissionColor);
props.SetFloat(WMS._CloudDirLightMultiplierVolumetric, CloudLayerVolumetric1.CloudDirLightMultiplier);
props.SetFloat(WMS._CloudLightDitherLevel, CloudLayerVolumetric1.CloudLightDitherLevel);
props.SetFloat(WMS._CloudPointSpotLightMultiplierVolumetric, CloudLayerVolumetric1.CloudPointSpotLightMultiplier);
props.SetFloat(WMS._CloudAmbientGroundIntensityVolumetric, CloudLayerVolumetric1.CloudAmbientGroundIntensity);
props.SetFloat(WMS._CloudAmbientSkyIntensityVolumetric, CloudLayerVolumetric1.CloudAmbientSkyIntensity);
float backgroundSkyStyle = (WeatherMakerSkySphereScript.Instance == null || WeatherMakerSkySphereScript.Instance.SkySphereProfile == null ||
WeatherMakerSkySphereScript.Instance.SkySphereProfile.SkyMode == WeatherMakeSkyMode.ProceduralUnityStyle ||
WeatherMakerSkySphereScript.Instance.SkySphereProfile.SkyMode == WeatherMakeSkyMode.ProceduralTexturedUnityStyle ? 0.0f : 1.0f);
props.SetVector(WMS._CloudBackgroundSkyIntensityVolumetric, new Vector4(CloudLayerVolumetric1.CloudSkyIntensity, backgroundSkyStyle, 0.0f, 0.0f));
props.SetFloat(WMS._CloudAmbientSkyHeightMultiplierVolumetric, CloudLayerVolumetric1.CloudAmbientSkyHeightMultiplier);
props.SetFloat(WMS._CloudAmbientGroundHeightMultiplierVolumetric, CloudLayerVolumetric1.CloudAmbientGroundHeightMultiplier);
props.SetFloat(WMS._CloudLightAbsorptionVolumetric, CloudLayerVolumetric1.CloudLightAbsorption);
props.SetFloat(WMS._CloudDirLightIndirectMultiplierVolumetric, CloudLayerVolumetric1.CloudDirLightIndirectMultiplier);
props.SetFloat(WMS._CloudPowderMultiplierVolumetric, CloudLayerVolumetric1.CloudPowderMultiplier.LastValue);
props.SetFloat(WMS._CloudOpticalDistanceMultiplierVolumetric, CloudLayerVolumetric1.CloudOpticalDistanceMultiplier);
props.SetFloat(WMS._CloudHorizonFadeMultiplierVolumetric, CloudLayerVolumetric1.CloudHorizonFadeMultiplier);
props.SetFloat(WMS._CloudDirLightSampleCount, WeatherMakerScript.Instance.PerformanceProfile.VolumetricCloudDirLightSampleCount);
props.SetFloat(WMS._CloudLightStepMultiplierVolumetric, WeatherMakerScript.Instance.PerformanceProfile.VolumetricCloudDirLightStepMultiplier);
props.SetFloat(WMS._CloudMaxRayLengthMultiplierVolumetric, WeatherMakerScript.Instance.PerformanceProfile.VolumetricCloudMaxRayLengthMultiplier);
props.SetFloat(WMS._CloudRayDitherVolumetric, WeatherMakerScript.Instance.PerformanceProfile.VolumetricCloudRayDither);
props.SetFloat(WMS._CloudRaymarchMultiplierVolumetric, Mathf.Max(CloudLayerVolumetric1.CloudMinRayMarchMultiplier, WeatherMakerScript.Instance.PerformanceProfile.VolumetricCloudRaymarchMultiplier));
props.SetVector(WMS._CloudRayMarchParameters, CloudLayerVolumetric1.CloudRayMarchParamers);
// sample details for dir light ray march if max lod is small
props.SetFloat(WMS._CloudDirLightLod, WeatherMakerScript.Instance.PerformanceProfile.VolumetricCloudDirLightLod);
props.SetInt(WMS._CloudRaymarchSampleDetailsForDirLight, WeatherMakerScript.Instance.PerformanceProfile.VolumetricCloudDirLightSampleDetails ? 1 : 0);
// flat
props.SetColorArray(WMS._CloudColor,
CloudLayer1.CloudColor * sun.GetGradientColor(CloudLayer1.CloudGradientColor),
CloudLayer2.CloudColor * sun.GetGradientColor(CloudLayer2.CloudGradientColor),
CloudLayer3.CloudColor * sun.GetGradientColor(CloudLayer3.CloudGradientColor),
CloudLayer4.CloudColor * sun.GetGradientColor(CloudLayer4.CloudGradientColor));
props.SetColorArray(WMS._CloudEmissionColor,
CloudLayer1.CloudEmissionColor,
CloudLayer2.CloudEmissionColor,
CloudLayer3.CloudEmissionColor,
CloudLayer4.CloudEmissionColor);
props.SetFloatArray(WMS._CloudAmbientMultiplier,
CloudLayer1.CloudAmbientMultiplier,
CloudLayer2.CloudAmbientMultiplier,
CloudLayer3.CloudAmbientMultiplier,
CloudLayer4.CloudAmbientMultiplier);
props.SetFloatArray(WMS._CloudScatterMultiplier,
CloudLayer1.CloudScatterMultiplier,
CloudLayer2.CloudScatterMultiplier,
CloudLayer3.CloudScatterMultiplier,
CloudLayer4.CloudScatterMultiplier);
/*
* if (CloudLayer1.CloudNoiseMask != null || CloudLayer2.CloudNoiseMask != null || CloudLayer3.CloudNoiseMask != null || CloudLayer4.CloudNoiseMask != null)
* {
* cloudMaterial.SetTexture(WMS._CloudNoiseMask1, CloudLayer1.CloudNoiseMask ?? Texture2D.whiteTexture);
* cloudMaterial.SetTexture(WMS._CloudNoiseMask2, CloudLayer2.CloudNoiseMask ?? Texture2D.whiteTexture);
* cloudMaterial.SetTexture(WMS._CloudNoiseMask3, CloudLayer3.CloudNoiseMask ?? Texture2D.whiteTexture);
* cloudMaterial.SetTexture(WMS._CloudNoiseMask4, CloudLayer4.CloudNoiseMask ?? Texture2D.whiteTexture);
* WeatherMakerShaderIds.SetVectorArray(cloudMaterial, "_CloudNoiseMaskOffset",
* CloudLayer1.CloudNoiseMaskOffset,
* CloudLayer2.CloudNoiseMaskOffset,
* CloudLayer3.CloudNoiseMaskOffset,
* CloudLayer4.CloudNoiseMaskOffset);
* WeatherMakerShaderIds.SetVectorArray(cloudMaterial, "_CloudNoiseMaskVelocity", cloudNoiseMaskVelocityAccum1, cloudNoiseMaskVelocityAccum2, cloudNoiseMaskVelocityAccum3, cloudNoiseMaskVelocityAccum4);
* WeatherMakerShaderIds.SetFloatArray(cloudMaterial, "_CloudNoiseMaskScale",
* (CloudLayer1.CloudNoiseMask == null ? 0.0f : CloudLayer1.CloudNoiseMaskScale * scaleReducer),
* (CloudLayer2.CloudNoiseMask == null ? 0.0f : CloudLayer2.CloudNoiseMaskScale * scaleReducer),
* (CloudLayer3.CloudNoiseMask == null ? 0.0f : CloudLayer3.CloudNoiseMaskScale * scaleReducer),
* (CloudLayer4.CloudNoiseMask == null ? 0.0f : CloudLayer4.CloudNoiseMaskScale * scaleReducer));
* WeatherMakerShaderIds.SetFloatArrayRotation(cloudMaterial, "_CloudNoiseMaskRotation",
* CloudLayer1.CloudNoiseMaskRotation.LastValue,
* CloudLayer2.CloudNoiseMaskRotation.LastValue,
* CloudLayer3.CloudNoiseMaskRotation.LastValue,
* CloudLayer4.CloudNoiseMaskRotation.LastValue);
* }
*/
props.SetFloatArray(WMS._CloudLightAbsorption,
CloudLayer1.CloudLightAbsorption,
CloudLayer2.CloudLightAbsorption,
CloudLayer3.CloudLightAbsorption,
CloudLayer4.CloudLightAbsorption);
}
private void Strike(Vector3?_start, Vector3?_end, bool intense, float intensity, Camera camera, bool forceVisible)
{
WeatherMakerCelestialObjectScript sun = WeatherMakerLightManagerScript.SunForCamera(camera);
if (sun == null)
{
return;
}
// save the generations and trunk width in case of cloud only lightning which will modify these properties
int generations = LightningBoltScript.Generations;
RangeOfFloats trunkWidth = LightningBoltScript.TrunkWidthRange;
if (UnityEngine.Random.value < CloudLightningChance)
{
// cloud only lightning
LightningBoltScript.TrunkWidthRange = new RangeOfFloats();
LightningBoltScript.Generations = 1;
}
Vector3 anchorPosition = camera.transform.position;
Vector3 start = _start ?? CalculateStartPosition(ref anchorPosition, (forceVisible ? camera : null), intense, LightningBoltScript.Generations <= 1);
Vector3 end = _end ?? CalculateEndPosition(ref anchorPosition, ref start, (forceVisible ? camera : null), intense);
float intensityModifier = 1.0f;
CameraMode mode = WeatherMakerScript.ResolveCameraMode(null, camera);
if (sun != null)
{
if (mode != CameraMode.Perspective)
{
float sunX = (sun.transform.eulerAngles.x + 180.0f);
sunX = (sunX >= 360.0f ? sunX - 360.0f : sunX);
sunX = Mathf.Abs((sunX * 0.5f) - 90.0f);
intensityModifier = Mathf.Lerp(0.1f, 0.75f, sunX * 0.016f);
}
else
{
float sunX = (sun.transform.eulerAngles.x + 90.0f);
sunX = (sunX >= 360.0f ? sunX - 360.0f : sunX);
sunX = Mathf.Abs((sunX * 0.5f) - 90.0f);
intensityModifier = Mathf.Lerp(0.1f, 0.75f, sunX * 0.006f);
}
}
LightningBoltScript.LightParameters.LightIntensity = Mathf.Max(1.0f, intensity * intensityModifier);
if (mode == CameraMode.Perspective)
{
if (LightningBoltScript.Generations > 1)
{
Vector3 lightStart = start;
if (camera != null)
{
// HACK: Pull light toward camera to light clouds better, for some reason the light appears behind the lightning bolt
// need to figure out why...
Vector3 toLight = camera.transform.position - lightStart;
lightStart += (toLight * 0.5f);
lightStart.y = 1000.0f;
}
LightningBoltScript.LightParameters.LightPosition = lightStart;
}
else
{
LightningBoltScript.LightParameters.LightPosition = start;
}
LightningBoltScript.LightParameters.LightRange = Random.Range(3000.0f, 6000.0f);
}
LightningBoltScript.Trigger(start, end);
// restore properties in case they were modified
LightningBoltScript.TrunkWidthRange = trunkWidth;
LightningBoltScript.Generations = generations;
}
private void Update()
{
if (Profile == null)
{
return;
}
nextChange -= Time.deltaTime;
if (nextChange <= 0.0f)
{
if (Profile.RefreshInterval.Minimum > 0.0f && Profile.RefreshInterval.Maximum > 0.0f)
{
nextChange = Profile.RefreshInterval.Random();
}
else
{
nextChange = float.MaxValue;
}
var em = meteorParticles.emission;
float value1 = Profile.EmissionRange.Random();
float value2 = Profile.EmissionRange.Random();
em.rateOverTime = new ParticleSystem.MinMaxCurve(Mathf.Min(value1, value2), Mathf.Max(value1, value2));
var mn = meteorParticles.main;
float l1 = Profile.LifetimeRangeMin.Random();
float l2 = Profile.LifetimeRangeMax.Random();
var lifeTime = mn.startLifetime;
lifeTime.constantMin = Mathf.Min(l1, l2);
lifeTime.constantMax = Mathf.Max(l1, l2);
mn.startLifetime = lifeTime;
l1 = Profile.SpeedRangeMin.Random();
l2 = Profile.SpeedRangeMax.Random();
speed = new Vector2(Mathf.Min(l1, l2), Mathf.Max(l1, l2));
// pick a random offset in the sky
offset = new Vector3(UnityEngine.Random.Range(Profile.OffsetMin.x, Profile.OffsetMax.x),
UnityEngine.Random.Range(Profile.OffsetMin.y, Profile.OffsetMax.y),
UnityEngine.Random.Range(Profile.OffsetMin.z, Profile.OffsetMax.z));
radius = Profile.RadiusRange.Random();
arc = Profile.ArcRange.Random();
}
// update color based on sun position
if (WeatherMakerLightManagerScript.Instance != null)
{
WeatherMakerCelestialObjectScript sun = (WeatherMakerLightManagerScript.Instance.SunPerspective ?? WeatherMakerLightManagerScript.Instance.SunOrthographic);
if (sun != null)
{
float a = sun.GetGradientColor(Profile.Visibility).r;
var m = meteorParticles.main;
var colorRange = m.startColor;
Color minColor = colorRange.colorMin;
Color maxcolor = colorRange.colorMax;
minColor.a = maxcolor.a = a;
colorRange.colorMin = minColor;
colorRange.colorMax = maxcolor;
m.startColor = colorRange;
}
}
}
