Simplest possible day night cycle in Unity 5

This is a quick tutorial on how to create the simplest possible day night cycle in Unity 5. Everything about it will be wrong compared to how it should be in real life, but chances are nobody will notice. And you can extend it with more features as you please.

Disclaimer: This is more of a "how I did it" rather than a fully fledged tutorial that you follow step by step. So If you're just interested in the end result scroll to the bottom to see an example webplayer or to download the project folder.

When you first start up Unity 5 chances are you have tried rotating the directional light that comes with the default starting scene. By doing that you've also probably noticed that the sun's position in the skybox as well as the color of the sky changes accordingly. So what I'm saying is that Unity 5 already does everything we need to create a day night cycle for us. All we need to do is control this rotation through a script.

Here's that script:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
using UnityEngine;
using System.Collections;
 
public class DayNightController : MonoBehaviour {
 
    public Light sun;
    public float secondsInFullDay = 120f;
    [Range(0,1)]
    public float currentTimeOfDay = 0;
    [HideInInspector]
    public float timeMultiplier = 1f;
    
    float sunInitialIntensity;
    
    void Start() {
        sunInitialIntensity = sun.intensity;
    }
    
    void Update() {
        UpdateSun();
 
        currentTimeOfDay += (Time.deltaTime / secondsInFullDay) * timeMultiplier;
 
        if (currentTimeOfDay >= 1) {
            currentTimeOfDay = 0;
        }
    }
    
    void UpdateSun() {
        sun.transform.localRotation = Quaternion.Euler((currentTimeOfDay * 360f) - 90, 170, 0);
 
        float intensityMultiplier = 1;
        if (currentTimeOfDay <= 0.23f || currentTimeOfDay >= 0.75f) {
            intensityMultiplier = 0;
        }
        else if (currentTimeOfDay <= 0.25f) {
            intensityMultiplier = Mathf.Clamp01((currentTimeOfDay - 0.23f) * (1 / 0.02f));
        }
        else if (currentTimeOfDay >= 0.73f) {
            intensityMultiplier = Mathf.Clamp01(1 - ((currentTimeOfDay - 0.73f) * (1 / 0.02f)));
        }
 
        sun.intensity = sunInitialIntensity * intensityMultiplier;
    }
}

You attach this script to a game object in the scene and then assign your directional light in the sun slot. What this script does is increase a value from 0 to 1 over the number of seconds we specify. This value defines a full 24 hour in game day where 0 is midnight, 0,25 is sunrise, 0,5 is noon, 0,75 is sunset. By default a full day and night takes 120 seconds as you can see. When the value reaches 1 we reset it back to 0 so that the next day can start.

UpdateSun() is what actually moves the sun. To rotate the sun across the sky the only thing we need is the first line. We rotate the sun 360 degrees around the x-axis according to the current time of day. We subtract 90 degrees from this to make the sun rise at 0.25 instead of 0. I just found that value easier to work with. The y-axis determines where on the horizon the sun will rise and set. I set this to 170 because it fit my test scene. The z-axis rotation does nothing here.

The rest of the UpdateSun() mehtod only deals with the intensity of our sun. We want the intensity of the sun to be 0 when it's below the horizon so it doesn't shine up from below the ground because that looks really weird. And I've also added some code to fade in the intensity when the sun rises and fade out the intensity when the sun sets. That's all there is to it.

But if you try this out now and you have some objects in your scene you will notice that the objects stays lit even during the night, even if you mark them as static. That is not what we want. To fix this there's 2 things you must do. The first is to add a "Reflection Probe" to the scene and set its type to "Realtime" and set the refresh mode to "Every frame":

Now any static geometry you add to the scene will be properly lit, but dynamic objects still won't receive the correct lighting. But we can fix this as well. Add a "Light Probe Group" to the scene. You don't have to change any settings for this to work. It works automatically. Now even dynamic objects will be properly lit by your dynamic sun.

You may have to tweak the settings and positions of your probes to make everything look perfect. But all that depends on your scene setup. I have added links to the official documentation entries for reflection probes and light probes to the bottom of this tutorial. There's a lot of information there if you stumble upon some problems. Or just ask me.

That's it, we're done now with the day night cycle now. But you probably noticed the clock in the image at the top of this tutorial. I added that because I thought it would be cool to actually see the current time of our day night cycle as time passes. I'll show you how I made it. It's all included in the project folder as well. The clock is based on this tutorial by Jasper Flick. He makes amazing Unity tutorials. Much more elaborate than this one. All I do is steal his stuff.

But anyway, the clock is just an object resembling a clock with another simple script attached. You can, and probably should, make the clock object as a 3d model in a modeling application, but I made it in Unity for this tutorial by just sticking a bunch of cube and cylinder primitives together. The only important parts of the clock object are the hands indicating the current hour and the current minute. We need to be able to reference them through script and they should be able to rotate 360 degrees around on a pivot in the center of the clock face. As for the clock script, here it is:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
using UnityEngine;
 
public class Clock : MonoBehaviour {
    
    public Transform hourHand;
    public Transform minuteHand;
    
    float hoursToDegrees = 360f / 12f;
    float minutesToDegrees = 360f / 60f;
    DayNightController controller;
    
    void Awake() {
        controller = GameObject.Find("DayNightController").GetComponent<DayNightController>();
    }
    
    void Update() {
        float currentHour = 24 * controller.currentTimeOfDay;
        float currentMinute = 60 * (currentHour - Mathf.Floor(currentHour));
        
        hourHand.localRotation = Quaternion.Euler(currentHour * hoursToDegrees, 0, 0);
        minuteHand.localRotation = Quaternion.Euler(currentMinute * minutesToDegrees, 0, 0);
    }
}

It's really simple. First we define how many hours there are per day and how many minutes there are per hour. Then we define how many degrees each hour should be on our clock face and how many degrees each minute is. In Update() we get the currentTimeOfDay variable (which is a float between 0 and 1) from the DayNightController and multiply that with the values we've defined to get the current hour and the current minute. We then rotate the hour hand and the minute hand of the clock face according to these values. Obviously we could do seconds here as well, but they would pass so rapidly I chose not to. Again this script is fully commented in the project.

And that's everything, or nearly everything. If you read through the DayNightController script you may have noticed the public timeMultiplier variable. That is there so other scripts can change how fast the day night cycle passes. I have added a small script to my scene which lets me speed up or slow down time using W, S or arrow up or arrow down. It's fully commented in the project folder. I also added Bloom to make it look Next-Gen^TM and I added a bunch of rigidbody spheres to show you that it works perfectly with dynamic moving objects. The emissive parts of the clock also show you how amazingly cool the real time global illumination in Unity 5 is.

Ways to improve this effect would be to make the sun actually move more realistically across the sky and not just directly across it, to make it so you can have longer days/nights, or to add a starry sky or even a moon. The sky's the limit.

Check out an example webplayer here:
/projects/unity-5-day-night-cycle-example-scene

Or download the entire project folder here if you want to have a look:
/sites/default/files/unity/project/day-night-cycle-1.0.1.zip

Here's the official documentation entry about Reflection Probes:
https://docs.unity3d.com/Manual/class-ReflectionProbe.html

Read about Light Probe Groups and Light Probes here:
https://docs.unity3d.com/Manual/class-LightProbeGroup.html

About Øyvind Strømsvik (TwiiK)

I've been passionate about games all my life and started dabbling in game development about 15 years ago with BlitzBasic,... read more but I quickly lost interest and began doing 3d modeling instead. 3d modeling remained a hobby and I picked up game development again around the release of Unity 2.0. My driving force behind wanting to get back into game development was my lost interest in commercial games as they started appealing to a group of gamers I was no longer in. Indie games were the only games that still looked interesting, but at the same time some of them looked like they would be just as fun to make as to actually play. And many of them were made by just one guy.