🎞️ Lesson 5.1: Loading Scenes: Single, Async & Loading Screens

Meet the SceneManager

A scene is a container for a slice of your game: its GameObjects, lighting, and settings. In Fundamentals you built inside a single scene. Real games have many, and the class that swaps between them at runtime is UnityEngine.SceneManagement.SceneManager.

The whole API starts with one using line:

using UnityEngine.SceneManagement;

Forget that line and SceneManager won't resolve — it lives in its own namespace, not the base UnityEngine. With it imported, loading the next level is a single call.

Scenes In Build: The Registry

Here's the rule that trips up everyone the first time: a scene can only be loaded at runtime if it's listed in Build Settings. A scene file sitting in your Project window is not enough. You have to register it.

Open File ▸ Build Profiles (in older layouts, File ▸ Build Settings). At the top is the Scenes In Build list. Drag your scenes in, or click Add Open Scenes. Each row gets an index, starting at 0 — and the scene at index 0 is the one your built game opens with.

Loading a Scene: Single Mode

The simplest load replaces everything on screen with a new scene. That's Single mode — the default. It destroys the current scene's objects, then loads the new one.

using UnityEngine;
using UnityEngine.SceneManagement;

public class MenuButtons : MonoBehaviour
{
    // Hook this to a "Play" button's OnClick in the Inspector
    public void StartGame()
    {
        // By name (must match the scene's file name, no extension)
        SceneManager.LoadScene("Level_1", LoadSceneMode.Single);
    }

    public void QuitToMenu()
    {
        // By build index — MainMenu is index 1 in Figure 1
        SceneManager.LoadScene(1);
    }
}

You can reference a scene two ways, and both appear above:

• By name ("Level_1") — readable and stable if you reorder the list. This is what you'll use most.
• By build index (1) — the number from the Scenes In Build list. Fast to type, but if you drag rows around the numbers shift under you.

LoadSceneMode.Single is the default, so SceneManager.LoadScene("Level_1") does the same thing. We'll meet Additive mode in the next lesson.

Why Big Scenes Freeze

LoadScene is synchronous: it stops everything, tears down the old scene, loads the new one, then hands control back — all in one frame. For a tiny menu that's instant and fine. For a large level with heavy meshes, textures, and lighting data, that "one frame" can stretch to a noticeable hitch: the window stops responding, audio may stutter, and on some platforms the OS shows a "Not Responding" flash.

The fix is to load asynchronously — spread the work across many frames so the game keeps rendering (a spinning loading animation, a progress bar) while the new scene streams in. That's LoadSceneAsync.

💡 Rule of thumb: Menus and tiny scenes → LoadScene is fine. Actual gameplay levels → always LoadSceneAsync with a loading screen. Players forgive a progress bar; they don't forgive a frozen window.

LoadSceneAsync & Progress

SceneManager.LoadSceneAsync returns an AsyncOperation — a handle you can poll while the load runs in the background. Its two useful members are:

• progress — a float from 0 to 0.9 while loading, jumping to 1.0 only after the scene is activated.
• allowSceneActivation — set it to false to hold the finished scene in the wings until you say go.

That 0.9 cap surprises everyone, so let's be precise about the flow before we write the coroutine:

Figure 2: The async load lifecycle. Progress climbs to 0.9 while loading; the last 10% is reserved for the activation step you control with allowSceneActivation.

A Real Loading Screen

Now we put it together. The pattern is a dedicated Loading scene (index 2 in Figure 1) containing just a full-screen Canvas with a fill-image progress bar. It reads which scene to load from a static field, runs a coroutine, and animates the bar.

using UnityEngine;

public static class SceneLoader
{
    // Any menu sets this, then loads the "Loading" scene.
    public static string TargetScene = "Level_1";
}

Your menu button first records the destination, then switches to the loading scene:

public void PlayLevel1()
{
    SceneLoader.TargetScene = "Level_1";
    SceneManager.LoadScene("Loading");   // tiny scene, instant is fine
}

And the loading scene runs this on Start:

using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using System.Collections;

public class LoadingScreen : MonoBehaviour
{
    [SerializeField] Image progressBar;   // a UI Image set to Filled
    [SerializeField] Text  progressLabel; // e.g. "42%"
    [SerializeField] GameObject pressAnyKeyPrompt;

    void Start() => StartCoroutine(LoadTarget());

    IEnumerator LoadTarget()
    {
        AsyncOperation op = SceneManager.LoadSceneAsync(SceneLoader.TargetScene);
        op.allowSceneActivation = false;   // hold at the finish line

        while (op.progress < 0.9f)
        {
            // remap 0..0.9 to a clean 0..1 for the bar
            float display = Mathf.Clamp01(op.progress / 0.9f);
            progressBar.fillAmount = display;
            progressLabel.text = Mathf.RoundToInt(display * 100f) + "%";
            yield return null;             // wait one frame, keep rendering
        }

        // Fully loaded and waiting. Show 100% and invite the player in.
        progressBar.fillAmount = 1f;
        progressLabel.text = "100%";
        pressAnyKeyPrompt.SetActive(true);

        // Wait for any key, then activate. (Input System: any control)
        while (!Input.anyKeyDown)
            yield return null;

        op.allowSceneActivation = true;    // swap to the new scene
    }
}

A few things worth noticing:

• yield return null pauses the coroutine for exactly one frame, so the UI redraws and the bar animates smoothly instead of the game freezing.
• Setting allowSceneActivation = false lets you gate the final swap on a "Press any key" prompt — great for showing a tip or letting a slow player catch up.
• If you'd rather activate instantly, just delete the allowSceneActivation line entirely and the scene swaps the moment it finishes.

💡 Why a separate Loading scene? Because Single-mode loading destroys the current scene. If your progress UI lived in the menu, it would be torn down mid-load. A dedicated tiny Loading scene survives on its own until it chooses to activate the target — nothing can destroy it out from under you.

Hands-on Challenge

Summary

🚀 What's Next?

So far every load has been Single mode — the new scene wipes out the old. But what if you want a persistent manager or a UI overlay to stay while levels stream in and out beneath it? In Lesson 5.2: Additive & Multi-Scene Workflows we load scenes on top of each other and learn to unload them cleanly.