Sun Positioning Script

2025-02-27 20:47 UTC o1 Open in ChatGPT ↗

You

Unity script for precise sun positioning based on longitude, latitude, date and time

ChatGPT

Below is a simple C# script you can use in a Unity project to position the Sun (i.e., a Directional Light) accurately in the sky based on latitude, longitude, date, and time. This script uses common astronomical formulas (similar to those provided by NOAA) to compute the Sun’s azimuth and altitude, then converts those angles into a transform.rotation suitable for Unity’s coordinate system.

Note

• This script focuses on direct solar positioning (ignoring refraction, atmospheric scattering, etc.).
• You can attach this script to a Directional Light GameObject to simulate the Sun’s position.
• Make sure you adjust or remove the ExecuteInEditMode attribute if you don’t want it to run continuously in the Editor.

---

SunPosition.cs

using System;
using UnityEngine;

/// <summary>
/// Attach this script to a Directional Light in your Unity scene.
/// It will set the light's rotation to match the sun's position
/// based on the specified location, date, and time.
/// </summary>
[ExecuteInEditMode]
public class SunPosition : MonoBehaviour
{
    [Header("Location (Degrees)")]
    [Tooltip("Latitude in degrees (negative for Southern Hemisphere)")]
    public float latitude = 0f;
    [Tooltip("Longitude in degrees (negative for Western Hemisphere)")]
    public float longitude = 0f;

    [Header("Date and Time (UTC)")]
    public int year = 2025;
    public int month = 2;
    public int day = 27;
    public int hour = 12;
    public int minute = 0;
    public int second = 0;

    [Header("UTC Offset (Hours)")]
    [Tooltip("Local time offset from UTC in hours (e.g., -5 for EST)")]
    public float utcOffset = 0f;

    void Update()
    {
        // Create a DateTime in UTC, then apply the user's UTC offset to get local time
        DateTime dateTime = new DateTime(year, month, day, hour, minute, second, DateTimeKind.Utc)
                            .AddHours(utcOffset);

        // Calculate the Sun's azimuth and altitude
        double azimuth, altitude;
        CalculateSunPosition(dateTime, latitude, longitude, out azimuth, out altitude);

        // Convert azimuth/altitude to a rotation for a Unity directional light
        // In typical astronomical convention:
        //   Altitude = 0 at horizon, +90 at zenith
        //   Azimuth = 0 at South (or North depending on definition), increasing towards West or East
        // In Unity (assuming Y is up), we can do a simple mapping:
        //   Tilt "down" by altitude and rotate around Y by azimuth
        transform.rotation = Quaternion.Euler((float)(-altitude), (float)azimuth, 0f);
    }

    /// <summary>
    /// Calculates the Sun's position in the sky for the given date/time and location.
    /// Returns azimuth (degrees) and altitude (degrees).
    /// </summary>
    /// <param name="dateTime">Local date/time (already adjusted for local offset if desired)</param>
    /// <param name="lat">Latitude in degrees</param>
    /// <param name="lon">Longitude in degrees</param>
    /// <param name="azimuth">Output azimuth in degrees (0 = North, 90 = East, etc.)</param>
    /// <param name="altitude">Output altitude in degrees (0 = horizon, +90 = zenith)</param>
    public void CalculateSunPosition(
        DateTime dateTime,
        double lat,
        double lon,
        out double azimuth,
        out double altitude)
    {
        // 1. Convert the date/time to Julian day
        double julianDay = GetJulianDay(dateTime);
        // Julian centuries from J2000.0
        double T = (julianDay - 2451545.0) / 36525.0;

        // 2. Calculate the Sun's mean anomaly, ecliptic longitude, etc.
        //    (Based on NOAA's solar calculations or standard astronomical formulas)

        double meanLong = 280.46646 + 36000.76983 * T;     // Mean longitude of the Sun (degrees)
        double meanAnom = 357.52911 + 35999.05029 * T;     // Mean anomaly of the Sun (degrees)
        double eccEarth = 0.016708634 - 0.000042037 * T;   // Eccentricity of Earth's orbit
        double sunEqCenter =
            (1.914602 - 0.004817 * T - 0.000014 * T * T) * Math.Sin(Deg2Rad(meanAnom)) +
            (0.019993 - 0.000101 * T) * Math.Sin(Deg2Rad(2 * meanAnom)) +
            0.000289 * Math.Sin(Deg2Rad(3 * meanAnom));

        double sunTrueLong = meanLong + sunEqCenter;       // Sun's true longitude (degrees)
        double sunAppLong = sunTrueLong - 0.00569 - 0.00478 * Math.Sin(Deg2Rad(125.04 - 1934.136 * T));

        // 3. Calculate the Sun's declination
        double meanObliqEcliptic = 23.439291 - 0.0130042 * T; // Mean obliquity of the ecliptic
        double obliqCorr = meanObliqEcliptic + 0.00256 * Math.Cos(Deg2Rad(125.04 - 1934.136 * T));

        // Sun's declination (delta)
        double sinDec = Math.Sin(Deg2Rad(obliqCorr)) * Math.Sin(Deg2Rad(sunAppLong));
        double declination = Rad2Deg(Math.Asin(sinDec));

        // 4. Calculate the Sun's right ascension
        double y = Math.Cos(Deg2Rad(obliqCorr)) * Math.Sin(Deg2Rad(sunAppLong));
        double x = Math.Cos(Deg2Rad(sunAppLong));
        double rightAscension = Rad2Deg(Math.Atan2(y, x));

        // Ensure RA is in [0, 360)
        if (rightAscension < 0) rightAscension += 360.0;

        // 5. Calculate the Sun's local hour angle
        //    First, compute "Greenwich Mean Sidereal Time" (GMST) in degrees
        double GMST = 280.46061837 + 360.98564736629 * (julianDay - 2451545.0)
                      + 0.000387933 * T * T - (T * T * T / 38710000.0);

        // Reduce GMST to [0, 360)
        GMST = GMST % 360.0;
        if (GMST < 0) GMST += 360.0;

        // Local Sidereal Time (LST) in degrees
        double LST = GMST + lon;
        LST = LST % 360.0;
        if (LST < 0) LST += 360.0;

        // Hour angle (HA) in degrees
        double HA = LST - rightAscension;
        if (HA < -180) HA += 360.0;
        if (HA > 180) HA -= 360.0;

        // 6. Convert to altitude and azimuth
        double latRad = Deg2Rad(lat);
        double decRad = Deg2Rad(declination);
        double HARad = Deg2Rad(HA);

        // Altitude
        double sinAlt = Math.Sin(latRad) * Math.Sin(decRad) +
                        Math.Cos(latRad) * Math.Cos(decRad) * Math.Cos(HARad);
        double alt = Rad2Deg(Math.Asin(sinAlt));

        // Azimuth
        double cosAz = (Math.Sin(decRad) - Math.Sin(latRad) * sinAlt) /
                       (Math.Cos(latRad) * Math.Cos(Deg2Rad(alt)));
        double az = Math.Acos(cosAz);
        double azDeg = Rad2Deg(az);

        // We need to determine the correct quadrant for azimuth
        // By convention: 0 = North, 90 = East, 180 = South, 270 = West
        // We'll adjust for the hour angle
        if (Math.Sin(HARad) > 0)
            azDeg = 360.0 - azDeg;

        // Output results
        azimuth = azDeg;
        altitude = alt;
    }

    /// <summary>
    /// Compute the Julian Day for the given DateTime (UTC-based).
    /// </summary>
    private double GetJulianDay(DateTime date)
    {
        // Convert to UTC if it's not already
        DateTime dateUtc = date.ToUniversalTime();
        int year = dateUtc.Year;
        int month = dateUtc.Month;
        double day = dateUtc.Day +
                     dateUtc.Hour / 24.0 +
                     dateUtc.Minute / 1440.0 +
                     dateUtc.Second / 86400.0;

        if (month <= 2)
        {
            year -= 1;
            month += 12;
        }

        int A = year / 100;
        int B = 2 - A + (A / 4);

        // Julian day formula
        double julianDay = Math.Floor(365.25 * (year + 4716))
                           + Math.Floor(30.6001 * (month + 1))
                           + day + B - 1524.5;

        return julianDay;
    }

    // Utility functions
    private double Deg2Rad(double deg) => Math.PI * deg / 180.0;
    private double Rad2Deg(double rad) => 180.0 * rad / Math.PI;
}

---

How It Works

1. Time & Location
   You specify the latitude (north/south), longitude (east/west), date, time, and UTC offset in the inspector.
2. Julian Day
   The script converts the given local or UTC-based time into a Julian Day. This is a continuous count of days from a reference point used in astronomical calculations.
3. Solar Coordinates
   It then calculates intermediate values such as the Sun’s mean anomaly, ecliptic longitude, right ascension, and declination using standard (NOAA-based) solar position formulas.
4. Altitude & Azimuth
   Using the local sidereal time and hour angle, it finds the Sun’s altitude (angle above the horizon) and azimuth (compass direction).
5. Unity Rotation
   Finally, it converts the altitude and azimuth into a Unity Quaternion rotation so that your Directional Light lines up with the Sun’s position in the sky.

Tips

• Adjust your Directional Light’s Intensity and Color as desired to simulate different times of day.
• For more frequent updates, keep the script in Update(). If you only need a single calculation (e.g., on scene load), move the call to Start() or OnValidate().
• If you need atmospheric effects (twilight, scattering, horizon haze, etc.), consider using specialized sky-rendering assets or implementing an atmospheric scattering shader.

This script should give you a precise Sun position in Unity for any date, time, and location you provide!

You

something about the angles seems flipped

ChatGPT

Below are a few common “gotchas” that can cause the Sun to appear flipped or reversed in Unity when using altitude/azimuth angles. Use the checklist and suggestions below to fix or customize the orientation so the Sun rises in the east, sets in the west, and has the correct elevation above the horizon.

---

1. Understanding the Coordinate Conventions

Astronomical Conventions

• Altitude (Elevation): Angle above the horizon (0° at horizon, +90° at zenith).
• Azimuth: Often 0° = North, 90° = East, 180° = South, 270° = West. (Some libraries or formulas instead use 0° = South or measure azimuth clockwise/counterclockwise differently.)

Unity Conventions

• Y-Axis is Up: In Unity’s default coordinate system, +Y is “up.”
• Directional Light “points” in its forward (Z) direction by default. So if the light’s transform.forward is aiming at the ground, that’s where the light rays go.

Because these two worlds (astronomical vs. Unity) don’t necessarily match one-to-one, you often have to invert or offset angles to make the visual result correct.

---

2. The Typical Symptoms of “Flipped Angles”

1. Sun rises in the West instead of the East
   Azimuth might be 180° off, or the sign of azimuth is reversed.

2. Sun is below the horizon at midday
   The altitude might be negated incorrectly, or the rotation logic needs a 90° offset.

3. Sun is rotated sideways
   Often a result of mixing altitude on the wrong axis or forgetting that some formulas treat 0° azimuth as South instead of North.

---

3. The Core Rotation Line

In the original script, there’s a line like:

transform.rotation = Quaternion.Euler((float)(-altitude), (float)azimuth, 0f);

Here’s what’s happening:

• -altitude is being applied around the X-axis.
• azimuth is being applied around the Y-axis.

This can work if your definitions match precisely, but if the sun is inverted or reversed, try one or more of the following adjustments:

1. Remove the minus sign on altitude:

   transform.rotation = Quaternion.Euler((float)altitude, (float)azimuth, 0f);

   If you see the sun pointing upwards at night (or vice versa), keep the minus sign.

2. Add a 90° offset to altitude or subtract from 90°:

   transform.rotation = Quaternion.Euler(90f - (float)altitude, (float)azimuth, 0f);

   or

   transform.rotation = Quaternion.Euler((float)(-altitude + 90f), (float)azimuth, 0f);

   Sometimes you need this if your forward vector is oriented differently (e.g., if you want altitude 0° to be purely horizontal).

3. Offset azimuth by 180° (or negate it):

   transform.rotation = Quaternion.Euler((float)(-altitude), (float)(azimuth + 180f), 0f);

   If you see your sunrises happening in the west, try adding or subtracting 180° to flip it.

You might need to experiment to see which tweak or combination of tweaks matches your desired orientation best.

---

4. Example Adjusted Script

Below is an example that aligns with a common convention:

• 0° azimuth = North, 90° = East
• The sun rises roughly in the East (azimuth = ~90° at sunrise)
• Altitude is 0° at horizon, +90° overhead.
• The directional light’s forward vector points toward the horizon at altitude = 0°, and points straight down at altitude = 90°.

using System;
using UnityEngine;

[ExecuteInEditMode]
public class SunPosition : MonoBehaviour
{
    [Header("Location (Degrees)")]
    public float latitude = 0f;   // +North, -South
    public float longitude = 0f;  // +East,  -West

    [Header("Date and Time (UTC)")]
    public int year = 2025;
    public int month = 2;
    public int day = 27;
    public int hour = 12;
    public int minute = 0;
    public int second = 0;

    [Header("UTC Offset (Hours)")]
    public float utcOffset = 0f;

    void Update()
    {
        // Convert the inspector date/time to local time as needed
        DateTime dateTime = new DateTime(year, month, day, hour, minute, second, DateTimeKind.Utc)
                            .AddHours(utcOffset);

        double azimuth, altitude;
        CalculateSunPosition(dateTime, latitude, longitude, out azimuth, out altitude);

        // ***************
        //  KEY CHANGE:
        //  We remove the negative on altitude and offset azimuth by +180 if needed.
        //  Try combinations based on your scene's orientation.
        // ***************

        // Example 1: Altitude directly on X, azimuth on Y:
        transform.rotation = Quaternion.Euler((float)(-altitude), (float)azimuth, 0f);

        // If sunrise is reversed, try:
        // transform.rotation = Quaternion.Euler((float)(-altitude), (float)(azimuth + 180f), 0f);
        // or remove the minus on altitude:
        // transform.rotation = Quaternion.Euler((float)altitude, (float)(azimuth + 180f), 0f);
    }

    public void CalculateSunPosition(
        DateTime dateTime,
        double lat,
        double lon,
        out double azimuth,
        out double altitude)
    {
        double julianDay = GetJulianDay(dateTime.ToUniversalTime());
        double T = (julianDay - 2451545.0) / 36525.0;

        double meanLong = 280.46646 + 36000.76983 * T;
        double meanAnom = 357.52911 + 35999.05029 * T;
        double eccEarth = 0.016708634 - 0.000042037 * T;

        double sunEqCenter =
            (1.914602 - 0.004817 * T - 0.000014 * T * T) * Math.Sin(Deg2Rad(meanAnom)) +
            (0.019993 - 0.000101 * T) * Math.Sin(Deg2Rad(2 * meanAnom)) +
             0.000289 * Math.Sin(Deg2Rad(3 * meanAnom));

        double sunTrueLong = meanLong + sunEqCenter;
        double sunAppLong = sunTrueLong - 0.00569 - 0.00478 * Math.Sin(Deg2Rad(125.04 - 1934.136 * T));

        double meanObliqEcliptic = 23.439291 - 0.0130042 * T;
        double obliqCorr = meanObliqEcliptic + 0.00256 * Math.Cos(Deg2Rad(125.04 - 1934.136 * T));

        // Sun's declination
        double sinDec = Math.Sin(Deg2Rad(obliqCorr)) * Math.Sin(Deg2Rad(sunAppLong));
        double declination = Rad2Deg(Math.Asin(sinDec));

        // Sun's right ascension
        double y = Math.Cos(Deg2Rad(obliqCorr)) * Math.Sin(Deg2Rad(sunAppLong));
        double x = Math.Cos(Deg2Rad(sunAppLong));
        double rightAscension = Rad2Deg(Math.Atan2(y, x));
        if (rightAscension < 0) rightAscension += 360.0;

        // Greenwich Mean Sidereal Time
        double GMST = 280.46061837 + 360.98564736629 * (julianDay - 2451545.0) +
                      0.000387933 * T * T - (T * T * T / 38710000.0);
        GMST = GMST % 360.0;
        if (GMST < 0) GMST += 360.0;

        // Local Sidereal Time
        double LST = GMST + lon;
        LST = LST % 360.0;
        if (LST < 0) LST += 360.0;

        // Hour Angle
        double HA = LST - rightAscension;
        if (HA < -180) HA += 360.0;
        if (HA > 180)  HA -= 360.0;

        // Convert to altitude/azimuth
        double latRad = Deg2Rad(lat);
        double decRad = Deg2Rad(declination);
        double HARad = Deg2Rad(HA);

        double sinAlt = Math.Sin(latRad) * Math.Sin(decRad) +
                        Math.Cos(latRad) * Math.Cos(decRad) * Math.Cos(HARad);
        double alt = Rad2Deg(Math.Asin(sinAlt));  // altitude

        double cosAz = (Math.Sin(decRad) - Math.Sin(latRad) * sinAlt) /
                       (Math.Cos(latRad) * Math.Cos(Deg2Rad(alt)));
        double az = Rad2Deg(Math.Acos(cosAz));    // preliminary azimuth

        // Correct quadrant for azimuth
        // NOAA convention: 0°=North, 90°=East, 180°=South, 270°=West
        if (Math.Sin(HARad) > 0)
            az = 360.0 - az;

        azimuth = az;
        altitude = alt;
    }

    private double GetJulianDay(DateTime date)
    {
        DateTime dateUtc = date.ToUniversalTime();
        int year = dateUtc.Year;
        int month = dateUtc.Month;
        double day = dateUtc.Day + dateUtc.Hour/24.0 + dateUtc.Minute/1440.0 + dateUtc.Second/86400.0;

        if (month <= 2)
        {
            year -= 1;
            month += 12;
        }

        int A = year / 100;
        int B = 2 - A + (A / 4);

        return Math.Floor(365.25 * (year + 4716))
             + Math.Floor(30.6001 * (month + 1))
             + day + B - 1524.5;
    }

    private double Deg2Rad(double deg) => Math.PI * deg / 180.0;
    private double Rad2Deg(double rad) => 180.0 * rad / Math.PI;
}

Trial & Error

• If sunrises happen in the West: add +180f to azimuth in the rotation, or remove it if you already have it.
• If the sun’s altitude is reversed: remove (or add) the minus sign on altitude.
• If the sun is sideways: try adding ±90 degrees to altitude, e.g. Quaternion.Euler(90f - altitude, azimuth, 0f).

---

5. Final Tips

1. Double-Check Your Input
   Make sure latitude is positive for the Northern Hemisphere and negative for the Southern. Longitude is positive for East of Greenwich and negative for West.

2. Watch Out for UTC vs. Local Time
   Ensure utcOffset is correct or that your DateTime is in UTC if your code expects UTC.

3. Experiment in Play Mode
   Expose an in-Editor slider for hour and watch how the sun moves. If it moves in the wrong direction, flip azimuth or altitude accordingly.

4. Skybox & Light Intensity
   Consider synchronizing a skybox material or adjusting your directional light’s intensity/color for a more realistic day/night cycle.

---

By tweaking those two lines (where altitude and azimuth get turned into a rotation), you can align the sun so it rises in the east and sets in the west, with altitude above the horizon as expected in Unity’s coordinate system.

You

create a single parameter T from 0 to 1 that animates from 6:00 to 18:00

ChatGPT

Below is a simple way to map a single parameter T from 0 to 1 onto a time range from 6:00 to 18:00. With T = 0 you get 6:00 AM, and with T = 1 you get 6:00 PM. You can then feed that hour/minute/second into your existing sun-position script.

---

Core Idea

• The span from 6:00 to 18:00 is 12 hours long.
• Given a parameter T ∈ [0, 1], we can interpolate linearly as follows: $ \text{timeInHours} = 6 + T \times 12 $
  • At T = 0 → timeInHours = 6 → 6:00 AM
  • At T = 1 → timeInHours = 18 → 6:00 PM

Then we split that into hour and minute:

1. hour = floor(timeInHours)
2. fraction = timeInHours - hour (the fractional part)
3. minute = fraction * 60
4. second = 0 (or you can interpolate seconds, if desired)

---

Example Code Snippet

Assume you have an existing SunPosition script that uses public hour, minute, second fields to set the sun’s time. You can add this snippet to Update() or another method:

using UnityEngine;

public class DayTimeAnimator : MonoBehaviour
{
    [Range(0f, 1f)]
    public float T = 0f; // 0..1 interpolates from 6:00 to 18:00

    // Reference to your SunPosition script
    public SunPosition sunPosition;

    void Update()
    {
        // 1. Compute total hours between 6:00 AM and 18:00 (6 PM)
        float totalHours = 6f + T * 12f;   // from 6 to 18

        // 2. Extract hour/minute
        int hourInt = Mathf.FloorToInt(totalHours);
        float fraction = totalHours - hourInt;
        int minuteInt = Mathf.FloorToInt(fraction * 60f);

        // (Optional) seconds if you want finer animation:
        // float minuteFraction = (fraction * 60f) - minuteInt;
        // int secondInt = Mathf.FloorToInt(minuteFraction * 60f);

        // 3. Assign to your SunPosition script
        sunPosition.hour = hourInt;
        sunPosition.minute = minuteInt;
        sunPosition.second = 0; // or secondInt
    }
}

How It Works

1. The DayTimeAnimator has a public float T in the Inspector (or you can change it via code).
2. T = 0 yields totalHours = 6, which becomes 6:00.
3. T = 1 yields totalHours = 18, which is 18:00 (6 PM).
4. Each frame, we split totalHours into integer hours and minutes (and optionally seconds).
5. We assign those values to the existing SunPosition script (or any other script that expects hour/minute/second).

Animating Over Time

If you want a continuous animation over some real-time duration (e.g., 10 seconds in real life to transition from 6:00 to 18:00), you could simply do:

void Update()
{
    // T goes from 0 to 1 over 10 seconds
    T += Time.deltaTime / 10f;
    T = Mathf.Clamp01(T);

    // then do the same hour/minute calculation as above...
}

This way, after 10 seconds of real-time, T will go from 0 up to 1, which corresponds to the sun going from 6:00 to 18:00 in the SunPosition script.

---

Tips

• Check UTC vs. Local: If your SunPosition script expects UTC, make sure you adjust or ignore the UTC offset for this simplified day animation.
• Easing: If you want a different speed profile (e.g., slow start, faster middle), you can apply an easing function (like T = T * T or Mathf.SmoothStep(0f, 1f, T)).
• Longer Ranges: To expand from 6:00 to 6:00 the next day (24-hour span), just change 12f to 24f in the interpolation.

You

also calculate light color based on the scattering equations

ChatGPT

Below is a simplified example of how you might calculate a directional light color in Unity based on approximate atmospheric scattering. This is by no means a complete physically-based sky model (e.g., Hosek–Wilkie or Bruneton), but it demonstrates how you might use Rayleigh-style attenuation to shift the sun’s color from warm (red/orange) at low altitudes to near-white at high altitudes.

Note

• This example is highly approximate. True atmospheric scattering is quite complex and typically computed in a sky shader rather than a single color.
• If you need a more accurate, physically-based solution, consider a full “physically based sky” approach or an existing asset (e.g. Enviro, Aura, or the Unity HDRP sky models).
• The code below at least shows how you can incorporate path-length–dependent scattering for a single directional light color.

---

High-Level Overview

1. Get the Sun’s Altitude (from your solar position script).
2. Compute Path Length: The lower the sun in the sky, the longer the path of light through the atmosphere, and the more the blue/green wavelengths get scattered away (leading to redder colors).
3. Apply Exponential Attenuation per color channel (R, G, B) using an approximate Rayleigh formula.
4. Set the Directional Light’s Color to the resulting attenuated color.

---

Example Code

Below is a script that you could attach to the same GameObject as your SunPosition script or any manager object that has a reference to your sun Directional Light and SunPosition. It assumes you have a float altitude in degrees from your SunPosition:

using UnityEngine;

/// <summary>
/// Approximate atmospheric scattering for the sun's directional light color.
/// Requires a reference to a SunPosition script (for altitude) and a Light component.
/// </summary>
[ExecuteInEditMode]
public class SunColorScattering : MonoBehaviour
{
    // Reference to your sun (Directional Light)
    public Light sunLight;

    // Reference to your solar position script
    public SunPosition sunPosition;

    [Header("Rayleigh Approximation Settings")]
    [Tooltip("Overall scattering scale. Increase to exaggerate red tint at sunrise/sunset.")]
    public float scatteringScale = 1.0f;

    [Tooltip("Rayleigh scattering coefficient for red (rough approximation)")]
    public float betaRayR = 5.5e-6f;

    [Tooltip("Rayleigh scattering coefficient for green (rough approximation)")]
    public float betaRayG = 1.0e-5f;

    [Tooltip("Rayleigh scattering coefficient for blue (rough approximation)")]
    public float betaRayB = 2.5e-5f;

    [Header("Mie Approximation (optional)")]
    [Tooltip("Mie scattering can make the sky more pale/yellowish at lower altitudes.")]
    public float betaMie = 2e-5f;
    public float mieFactor = 1.0f;

    // The altitude threshold below which we clamp, to avoid huge path lengths or negative altitudes
    private const float MIN_ALTITUDE = 0.1f; // degrees, just to prevent division by zero

    void Update()
    {
        if (sunLight == null || sunPosition == null) return;

        // 1. Get the sun altitude from your SunPosition script
        double altitudeDeg = sunPosition.GetCurrentAltitude();
        // (If you store altitude in a public variable, just read that.)

        // 2. Convert altitude to radians for math
        //    Clamp altitude so it doesn't go negative or near zero in the formula
        float altRad = Mathf.Max((float)(altitudeDeg * Mathf.Deg2Rad), MIN_ALTITUDE * Mathf.Deg2Rad);

        // 3. Approximate the optical path length:
        //    We use 1 / sin(altitude) as a super-simplified air mass model.
        float airMass = 1.0f / Mathf.Sin(altRad);

        // 4. Rayleigh Scattering Attenuation
        //    Beer-Lambert law: I = I0 * exp(-beta * path_length)
        //    Here we do channel-wise for R, G, B using approximate beta values.
        float attenR = Mathf.Exp(-betaRayR * scatteringScale * airMass);
        float attenG = Mathf.Exp(-betaRayG * scatteringScale * airMass);
        float attenB = Mathf.Exp(-betaRayB * scatteringScale * airMass);

        // 5. (Optional) Mie Scattering Attenuation
        //    We add an extra Mie factor that typically dims *all* wavelengths more uniformly,
        //    making the color more reddish at low altitude.
        //    This is also a large approximation.
        float attenMie = Mathf.Exp(-betaMie * mieFactor * airMass);

        // Combine: overall transmittance per channel
        // Mie is pretty broad, so we multiply it across all channels
        float finalR = attenR * attenMie;
        float finalG = attenG * attenMie;
        float finalB = attenB * attenMie;

        // 6. The sun's "intrinsic" color is close to white (~6500K).
        //    We'll multiply that white by the scattering attenuation.
        //    If you want a slightly warm midday sun, start with a color like (1.0, 0.98, 0.95).
        Color sunBaseColor = Color.white;
        // Or: new Color(1.0f, 0.98f, 0.95f) to simulate a slightly warmer midday color

        Color scatteredColor = new Color(
            sunBaseColor.r * finalR,
            sunBaseColor.g * finalG,
            sunBaseColor.b * finalB
        );

        // 7. Set the sun light color
        sunLight.color = scatteredColor;
    }
}

Getting the Altitude from SunPosition

• If your SunPosition script already computes altitude in Update(), you can expose it in a public property or method:

  public double GetCurrentAltitude()
  {
      // assume you store it each frame:
      return currentAltitude;
  }

• Or if your SunPosition calculates altitude on the fly, just replicate that calculation (or store the result in a public variable).

Typical Values

• betaRayR, betaRayG, betaRayB: these are very approximate orders of magnitude for Rayleigh coefficients, scaled to fit a “unitless” approach. You can tweak them to get a pleasing result.
• betaMie: also an approximation, can be tuned for haze/pollution.
• scatteringScale: set to 1 for a default. Increase if you want more intense red at low altitudes.

---

How It Works (Simplified)

1. Altitude → Path Length
   When the sun is near the horizon, its light travels through a thicker cross-section of the atmosphere. We approximate that with airMass = 1 / sin(alt).

2. Beer–Lambert Exponential
   For each color channel, we do I = I₀ × e^(-β × airMass). Because shorter wavelengths (blue) are scattered more strongly, we use bigger β for the blue channel, so it gets attenuated faster at low altitudes. That yields a warmer (more red) color near sunrise/sunset.

3. Mie Scattering (optional)
   Mie scattering primarily affects larger particles and is less wavelength-dependent, dimming all channels more evenly. This helps simulate haze or pollution and further reddens the low sun.

4. Multiply by Base Color
   In reality, the sun’s spectral distribution is ~5800–6500 K blackbody, a little yellowish-white. For simplicity, we used Color.white, or you can pick a slightly warm color for midday.

---

Final Notes

• Clamping: Real altitudes can go negative (below horizon) or above 90° (overhead). You may want to clamp altitude to [0, 90] in your scattering formula or fade out the sun’s intensity if it’s below the horizon.
• Night Transitions: Once the sun goes below the horizon, you might set the sun’s intensity to 0 or fade it out over a small altitude range.
• More Advanced Models: True sky rendering typically involves splitting into Rayleigh and Mie scattering terms for the entire sky dome, plus multiple scattering, ozone absorption, etc. The code above is just a single pass approximation for the sun color.

By combining this scattering-based color calculation with your daytime parameter (T) and SunPosition calculations, you’ll get a simple daylight color animation that shifts realistically from warm red/orange at sunrise/sunset to nearly white at midday.

You

the color is constantly white, although the altitude is changing

ChatGPT

If your computed sun color stays white (or nearly white) at all times—even when altitude is changing—there are a few common culprits:

1. Altitude is Very High (Close to Noon)

   • If your script calculates an altitude near 90° for most of your “daytime,” the air mass (1 / sin(altitude)) is close to 1. The exponential attenuation e^(-β × pathLength) remains very close to 1.0 for small path lengths, which results in nearly white color.
   • Quick Fix: Try setting your time to near sunrise/sunset so that altitude is low (e.g., 0°–15° above horizon). Or artificially pick a time/location that guarantees a low sun to see the color shift.

2. Scattering Coefficients Too Small

   • The default “betaRay” values (e.g. 5.5e-6, 1.0e-5, 2.5e-5) are quite small. If you’re only at moderate air mass (1–3), the exponent -β × pathLength is still a very tiny negative number, making e^(tiny number) ~ 1.0.
   • Quick Fix: Increase scatteringScale by 100× or more (e.g. 100f instead of 1f) to see if the color noticeably changes at lower altitudes.

3. Altitude Not Updating or Reference Not Set

   • Verify that your SunPosition script is actually returning a changing altitude (e.g., log it out or watch it in the Inspector). If SunPosition.GetCurrentAltitude() always returns 90° or some constant, your scattering code will remain white.
   • Quick Fix: Add a Debug.Log("Altitude: " + altitudeDeg) in SunColorScattering.Update() and watch the console to ensure it’s changing.

4. Using Degrees Instead of Radians Incorrectly

   • Make sure you convert altitude (in degrees) to radians before calling Mathf.Sin(). The example does altRad = altitudeDeg * Mathf.Deg2Rad. If you forget that step, Mathf.Sin(altitudeDeg) is effectively sin(90), which is near 0.9 for 90°, but for 30° is 0.5, etc.
   • If you see strange results, double-check your radian/degree conversions.

5. You’re Always Observing Midday Only

   • If your day parameter “T” (0 → 6:00, 1 → 18:00) leads to a sunrise that’s actually not that low in altitude (for your chosen latitude and date), you might never see the very red horizon condition. Real-world sunrise altitudes can be 0°, but if your script or location are offset, you might see the sun is already ~15° or 20° up at “6:00,” making it fairly white.
   • Quick Fix: Either use a date/latitude combination you know yields an actual sunrise near 6:00, or explicitly test with a forced altitude to confirm the color math.

---

Debugging Steps

1. Log Altitude

   float altDeg = (float) sunPosition.GetCurrentAltitude();
   Debug.Log($"Sun Altitude = {altDeg} degrees");

   Make sure it’s actually changing between near 0° (sunrise) and 90° (noon).

2. Log the Air Mass and Color

   Debug.Log($"Air Mass = {airMass}, Color = {scatteredColor}");

   See if airMass is something like 1.0 (midday) or up to 38 (sun on the horizon, though realistic max ~ 38 for 0° altitude). Also check if your final color is 1,1,1 because the exponent is effectively zero.

3. Increase Scattering

   • Temporarily set:

     scatteringScale = 100f;
     betaRayR = 5.5e-5f;
     betaRayG = 1.0e-4f;
     betaRayB = 2.5e-4f;

     Then drag a slider to move the sun altitude from 0° → 90°. You should see a big color shift.

4. Confirm the Time/Date

   • If you’re animating from 6:00 to 18:00, ensure the SunPosition truly yields low altitudes near 6:00. For some latitudes and dates, sunrise may not align at exactly 6 AM in that location.

---

If You Still See White

• At Very High Altitude (60°–90°), the color is almost white by nature, so it might be correct. You’d only see a noticeable shift below ~15° altitude.
• Double-Check your references to the Light and SunPosition are assigned in the Inspector. If sunLight is null or sunPosition is null, the script does nothing.

By verifying that you actually have a low altitude (5°–10° or less), increasing the scattering scale, and ensuring the references and conversions are correct, you should start seeing the sun color shift from white at midday to a more orange/red near the horizon.