/// <summary> Compute Optimized Optical Depth. </summary>
/// <param name="yPos"> Y axis pos. </param>
/// <param bame="sr"></param>
/// <param name="sm"></param>
public void OptimizedOpticalDepth(float yPos, out float sr, out float sm)
{
yPos = LSky_Mathf.Saturate(yPos * parameters.atmosphereHaziness);
yPos = 1.0f / (yPos + parameters.atmosphereZenith);
sr = parameters.rayleighZenithLength * yPos;
sm = parameters.mieZenithLength * yPos;
}
/// <summary> Compute Optical Depth Based On Nielsen Paper. </summary>
/// <param name="yPos"> Y axis pos. </param>
/// <param bame="sr"></param>
/// <param name="sm"></param>
public void NielsenOpticalDepth(float yPos, out float sr, out float sm)
{
yPos = LSky_Mathf.Saturate(yPos);
float f = Mathf.Pow(yPos, parameters.atmosphereHaziness);
float t = (1.05f - f) * 190000;
sr = t + f * (parameters.rayleighZenithLength - t);
sm = t + f * (parameters.mieZenithLength - t);
}
/// <summary>
/// Compute Custom Optical Depth.
/// Optical depth with small changes for more customization.
/// </summary>
/// <param name="yPos"> Y axis pos. </param>
/// <param bame="sr"></param>
/// <param name="sm"></param>
public void CustomOpticalDepth(float yPos, out float sr, out float sm)
{
yPos = LSky_Mathf.Saturate(yPos * parameters.atmosphereHaziness);
float zenith = Mathf.Acos(yPos);
zenith = Mathf.Cos(zenith) + 0.15f * Mathf.Pow(93.885f - ((zenith * 180.0f) / Mathf.PI), -1.253f);
zenith = 1.0f / (zenith + (parameters.atmosphereZenith * 0.5f));
sr = parameters.rayleighZenithLength * zenith;
sm = parameters.mieZenithLength * zenith;
}
/// <summary>
/// Compute Custom Optical Depth.
/// </summary>
/// <param name="yPos"> Y axis pos. </param>
/// <param bame="sr"></param>
/// <param name="sm"></param>
public void OpticalDepth(float yPos, out float sr, out float sm)
{
yPos = LSky_Mathf.Saturate(yPos);
float zenith = Mathf.Acos(yPos);
zenith = Mathf.Cos(zenith) + 0.15f * Mathf.Pow(93.885f - ((zenith * 180.0f) / Mathf.PI), -1.253f);
zenith = 1.0f / zenith;
sr = parameters.rayleighZenithLength * zenith;
sm = parameters.mieZenithLength * zenith;
}
public Color AtmosphericScattering(float sr, float sm, float sunCosTheta, float moonCosTheta, bool enableMiePhase, float sunEvaluateTime)
{
// Combined Extinction Factor.
Vector3 fex;
fex.x = Mathf.Exp(-(betaRay.x * sr + betaMie.x * sm));
fex.y = Mathf.Exp(-(betaRay.y * sr + betaMie.y * sm));
fex.z = Mathf.Exp(-(betaRay.z * sr + betaMie.z * sm));
Vector3 nfex = Vector3.one - fex;
Vector3 nfexm;
nfexm.x = nfex.x * fex.x;
nfexm.y = nfex.y * fex.y;
nfexm.z = nfex.z * fex.z;
Vector3 combExcFac = LSky_Mathf.Saturate(Vector3.Lerp(nfex, nfexm, SunsetDawnHorizon));
float SunRayleighPhase = RayleighPhase(sunCosTheta);
// Sun/Day
Vector3 sunBRT;
sunBRT.x = betaRay.x * SunRayleighPhase;
sunBRT.y = betaRay.y * SunRayleighPhase;
sunBRT.z = betaRay.z * SunRayleighPhase;
float sunMiePhase = enableMiePhase ? MiePhase(parameters.sunMie.anisotropy, sunCosTheta) * parameters.scattering : 1.0f;
Vector3 sunBMT;
sunBMT.x = sunMiePhase * parameters.sunMie.tint.r * betaMie.x;
sunBMT.y = sunMiePhase * parameters.sunMie.tint.g * betaMie.y;
sunBMT.z = sunMiePhase * parameters.sunMie.tint.b * betaMie.z;
Vector3 sunBRMT;
sunBRMT.x = (sunBRT.x + sunBMT.x) / (betaRay.x + betaMie.x);
sunBRMT.y = (sunBRT.y + sunBMT.y) / (betaRay.y + betaMie.y);
sunBRMT.z = (sunBRT.z + sunBMT.z) / (betaRay.z + betaMie.z);
Vector3 sunScatter; Color sunAtmosphereTint = parameters.sunAtmosphereTint.Evaluate(sunEvaluateTime);
sunScatter.x = DayIntensity * (sunBRMT.x * combExcFac.x) * sunAtmosphereTint.r;
sunScatter.y = DayIntensity * (sunBRMT.y * combExcFac.y) * sunAtmosphereTint.g;
sunScatter.z = DayIntensity * (sunBRMT.z * combExcFac.z) * sunAtmosphereTint.b;
Color result = new Color(0.0f, 0.0f, 0.0f, 1.0f);
if (moonRayleighMode != LSky_CelestialRayleighMode.Off)
{
Vector3 moonScatter;
// Simple Moon Scatter.
moonScatter.x = NightIntensity * nfex.x * parameters.moonAtmosphereTint.r;
moonScatter.y = NightIntensity * nfex.y * parameters.moonAtmosphereTint.g;
moonScatter.z = NightIntensity * nfex.x * parameters.moonAtmosphereTint.b;
float moonMiePhase = enableMiePhase ? LQHenyeyGreenstein(parameters.moonMie.anisotropy, moonCosTheta) * parameters.moonMie.scattering : 1.0f;
moonScatter.x += moonMiePhase * parameters.moonMie.tint.r;
moonScatter.y += moonMiePhase * parameters.moonMie.tint.g;
moonScatter.z += moonMiePhase * parameters.moonMie.tint.b;
result.r = sunScatter.x + moonScatter.x;
result.g = sunScatter.y + moonScatter.y;
result.b = sunScatter.z + moonScatter.z;
}
else
{
result.r = sunScatter.x;
result.g = sunScatter.y;
result.b = sunScatter.z;
}
return(result);
}
/// <summary>
/// Compute Moon Coordinates without perturbations.
/// Get moon azimuth and altitude.
/// </summary>
public void ComputeMoonCoords()
{
#region |Orbital Elements|
// Orbital elements in radians.
float N_Rad = Mathf.Deg2Rad * MoonOE.N;
float i_Rad = Mathf.Deg2Rad * MoonOE.i;
float M_Rad = Mathf.Deg2Rad * MoonOE.M;
#endregion
#region |Eccentric Anomaly|
// Compute eccentric anomaly.
float E = MoonOE.M + Mathf.Rad2Deg * MoonOE.e * Mathf.Sin(M_Rad) * (1 + SunOE.e * Mathf.Cos(M_Rad));
// Eccentric anomaly to radians.
float E_Rad = Mathf.Deg2Rad * E;
#endregion
#region |Rectangular Coordinates|
// Rectangular coordinates of the sun in the plane of the ecliptic.
float xv = MoonOE.a * (Mathf.Cos(E_Rad) - MoonOE.e); // Debug.Log(xv);
float yv = MoonOE.a * (Mathf.Sin(E_Rad) * Mathf.Sqrt(1 - MoonOE.e * MoonOE.e)) * Mathf.Sin(E_Rad); // Debug.Log(yv);
// Convert to distance and true anomaly(r = radians, v = degrees).
float r = Mathf.Sqrt(xv * xv + yv * yv); // Debug.Log(r);
float v = Mathf.Rad2Deg * Mathf.Atan2(yv, xv); // Debug.Log(v);
v = LSky_Mathf.NormalizeDegrees(v);
// Longitude in radians.
float l = Mathf.Deg2Rad * (v + MoonOE.w);
float Cos_l = Mathf.Cos(l);
float Sin_l = Mathf.Sin(l);
float Cos_N_Rad = Mathf.Cos(N_Rad);
float Sin_N_Rad = Mathf.Sin(N_Rad);
float Cos_i_Rad = Mathf.Cos(i_Rad);
float xeclip = r * (Cos_N_Rad * Cos_l - Sin_N_Rad * Sin_l * Cos_i_Rad);
float yeclip = r * (Sin_N_Rad * Cos_l + Cos_N_Rad * Sin_l * Cos_i_Rad);
float zeclip = r * (Sin_l * Mathf.Sin(i_Rad));
#endregion
#region Geocentric Coordinates.
// Geocentric position for the moon and Heliocentric position for the planets.
float lonecl = Mathf.Rad2Deg * Mathf.Atan2(yeclip, xeclip);
// Rev lonecl
lonecl = LSky_Mathf.NormalizeDegrees(lonecl); // Debug.Log(lonecl);
float latecl = Mathf.Rad2Deg * Mathf.Atan2(zeclip, Mathf.Sqrt(xeclip * xeclip + yeclip * yeclip)); // Debug.Log(latecl);
// Get true sun longitude.
// float lonSun = TrueSunLongitude;
// Ecliptic longitude and latitude in radians.
float lonecl_Rad = Mathf.Deg2Rad * lonecl;
float latecl_Rad = Mathf.Deg2Rad * latecl;
float nr = 1.0f;
float xh = nr * Mathf.Cos(lonecl_Rad) * Mathf.Cos(latecl_Rad);
float yh = nr * Mathf.Sin(lonecl_Rad) * Mathf.Cos(latecl_Rad);
float zh = nr * Mathf.Sin(latecl_Rad);
// Geocentric posisition.
float xs = 0.0f;
float ys = 0.0f;
// Convert the geocentric position to heliocentric position.
float xg = xh + xs;
float yg = yh + ys;
float zg = zh;
#endregion
#region |Equatorial Coordinates|
// Convert xg, yg in equatorial coordinates.
float oblecl_Cos = Mathf.Cos(Oblecl);
float oblecl_Sin = Mathf.Sin(Oblecl);
float xe = xg;
float ye = yg * oblecl_Cos - zg * oblecl_Sin;
float ze = yg * oblecl_Sin + zg * oblecl_Cos;
#endregion
#region |Ascension, Declination And Hour Angle|
// Right ascension.
float RA = Mathf.Rad2Deg * Mathf.Atan2(ye, xe); //Debug.Log(RA);
// Normalize right ascension.
RA = LSky_Mathf.NormalizeDegrees(RA); //Debug.Log(RA);
// Declination.
float Decl = Mathf.Rad2Deg * Mathf.Atan2(ze, Mathf.Sqrt(xe * xe + ye * ye));
// Declination in radians.
float Decl_Rad = Mathf.Deg2Rad * Decl;
// Hour angle.
float HA = ((SideralTime * 15) - RA); //Debug.Log(HA);
// Rev hour angle.
HA = LSky_Mathf.NormalizeDegrees(HA); //Debug.Log(HA);
// Hour angle in radians.
float HA_Rad = Mathf.Deg2Rad * HA;
#endregion
#region |Declination in rectangular coordinates|
// HA y Decl in rectangular coordinates.
float Decl_Cos = Mathf.Cos(Decl_Rad);
float xr = Mathf.Cos(HA_Rad) * Decl_Cos;
float yr = Mathf.Sin(HA_Rad) * Decl_Cos;
float zr = Mathf.Sin(Decl_Rad);
// Rotate the rectangualar coordinates system along of the Y axis(radians).
float sinLatitude = Mathf.Sin(Latitude_Rad);
float cosLatitude = Mathf.Cos(Latitude_Rad);
float xhor = xr * sinLatitude - zr * cosLatitude;
float yhor = yr;
float zhor = xr * cosLatitude + zr * sinLatitude;
#endregion
#region |Azimuth, Altitude And Zenith[Radians]|
m_MoonCoords.azimuth = Mathf.Atan2(yhor, xhor) + Mathf.PI;
m_MoonCoords.altitude = LSky_Mathf.k_HalfPI - Mathf.Atan2(zhor, Mathf.Sqrt(xhor * xhor + yhor * yhor)); // Altitude.
#endregion
}
/// <summary>
/// Compute Sun Coordinates.
/// Get sun azimuth and altitude.
/// </summary>
public void ComputeSunCoords()
{
#region |Orbital Elements|
// Mean Anomaly in radians.
float M_Rad = SunOE.M * Mathf.Deg2Rad;
#endregion
#region |Eccentric Anomaly|
// Compute eccentric anomaly.
float E = SunOE.M + Mathf.Rad2Deg * SunOE.e * Mathf.Sin(M_Rad) * (1 + SunOE.e * Mathf.Cos(M_Rad));
// Eccentric anomaly to radians.
float E_Rad = Mathf.Deg2Rad * E;// Debug.Log(E);
#endregion
#region |Rectangular Coordinates|
// Rectangular coordinates of the sun in the plane of the ecliptic.
float xv = (Mathf.Cos(E_Rad) - SunOE.e); // Debug.Log(xv);
float yv = (Mathf.Sin(E_Rad) * Mathf.Sqrt(1 - SunOE.e * SunOE.e)); // Debug.Log(yv);
// Convert to distance and true anomaly(r = radians, v = degrees).
float r = Mathf.Sqrt(xv * xv + yv * yv); // Debug.Log(r);
float v = Mathf.Rad2Deg * Mathf.Atan2(yv, xv); // Debug.Log(v);
// Get sun distance.
SunDistance = r;
#endregion
#region |True Longitude|
// True sun longitude.
float lonsun = v + SunOE.w;
// Normalize sun longitude
lonsun = LSky_Mathf.NormalizeDegrees(lonsun); // Debug.Log(lonsun);
// True sun longitude to radians.
float lonsun_Rad = Mathf.Deg2Rad * lonsun;
// Set true sun longitude(radians) for use in others celestials calculations.
TrueSunLongitude = lonsun_Rad;
#endregion
#region |Ecliptic And Equatorial Coordinates|
// Ecliptic rectangular coordinates(radians):
float xs = r * Mathf.Cos(lonsun_Rad);
float ys = r * Mathf.Sin(lonsun_Rad);
// Ecliptic rectangular coordinates rotate these to equatorial coordinates(radians).
float oblecl_Cos = Mathf.Cos(Oblecl);
float oblecl_Sin = Mathf.Sin(Oblecl);
float xe = xs;
float ye = ys * oblecl_Cos - 0.0f * oblecl_Sin;
float ze = ys * oblecl_Sin + 0.0f * oblecl_Cos;
#endregion
#region |Ascension And Declination|
// Right ascension(degrees):
float RA = Mathf.Rad2Deg * Mathf.Atan2(ye, xe) / 15;
// Declination(radians).
float Decl = Mathf.Atan2(ze, Mathf.Sqrt(xe * xe + ye * ye));
#endregion
#region |Mean Longitude|
// Mean sun longitude(degrees).
float L = SunOE.w + SunOE.M;
// Rev mean sun longitude.
L = LSky_Mathf.NormalizeDegrees(L);
// Set mean sun longitude for use in other celestials calculations.
MeanSunLongitude = L;
#endregion
#region |Sideral Time|
// Sideral time(degrees).
float GMST0 = /*(L + 180) / 15;*/ ((L / 15) + 12);
SideralTime = GMST0 + TotalHours_UTC + longitude / 15 + 15 / 15;
LocalSideralTime = Mathf.Deg2Rad * SideralTime * 15;
// Hour angle(degrees).
float HA = (SideralTime - RA) * 15; // Debug.Log(HA);
// Hour angle in radians.
float HA_Rad = Mathf.Deg2Rad * HA; // Debug.Log(HA);
#endregion
#region |Hour Angle And Declination In Rectangular Coordinates|
// HA anf Decl in rectangular coordinates(radians).
float Decl_Cos = Mathf.Cos(Decl);
// X axis points to the celestial equator in the south.
float x = Mathf.Cos(HA_Rad) * Decl_Cos;// Debug.Log(x);
// Y axis points to the horizon in the west.
float y = Mathf.Sin(HA_Rad) * Decl_Cos; // Debug.Log(y);
// Z axis points to the north celestial pole.
float z = Mathf.Sin(Decl);// Debug.Log(z);
// Rotate the rectangualar coordinates system along of the Y axis(radians).
float sinLatitude = Mathf.Sin(Latitude_Rad);
float cosLatitude = Mathf.Cos(Latitude_Rad);
float xhor = x * sinLatitude - z * cosLatitude; // Debug.Log(xhor);
float yhor = y;
float zhor = x * cosLatitude + z * sinLatitude; // Debug.Log(zhor);
#endregion
#region Azimuth, Altitude And Zenith[Radians].
m_SunCoords.azimuth = Mathf.Atan2(yhor, xhor) + Mathf.PI; // Azimuth.
m_SunCoords.altitude = LSky_Mathf.k_HalfPI - Mathf.Atan2(zhor, Mathf.Sqrt(xhor * xhor + yhor * yhor)); // Altitude.
#endregion
}
