🧩 Lesson 5.2: Additive & Multi-Scene Workflows

Stacking Scenes: Additive Mode

In Lesson 5.1 every load was LoadSceneMode.Single — it wiped the current scene first. Switch the mode to Additive and the new scene loads on top, with the existing one still running:

using UnityEngine.SceneManagement;

// Keep whatever is loaded; add Level_1 alongside it.
SceneManager.LoadScene("Level_1", LoadSceneMode.Additive);

// Async additive — the usual choice for streaming a level.
AsyncOperation op = SceneManager.LoadSceneAsync("Level_1", LoadSceneMode.Additive);

Now two (or more) scenes are live simultaneously. Their root GameObjects all appear in the Hierarchy under separate scene headers, they all get Update ticks, and their objects can see each other. This unlocks a powerful structure: a small, permanent scene that owns your game's systems, plus level scenes that come and go.

The Multi-Scene Hierarchy

When several scenes are loaded additively, the Hierarchy window groups objects under one header per scene. Here's a typical setup: a permanent Manager scene, the current Level_1, and a separate UI overlay scene, all loaded together.

The Active Scene

With several scenes loaded, Unity needs to know which one is "in charge" for a few defaults. That's the active scene (bold in the Hierarchy). It decides:

• Where newly Instantiated objects go if you don't say otherwise.
• Which scene's lighting and skybox settings are used for the render.

After you additively load a level, promote it to active so spawns and lighting come from it, not the Manager scene:

using UnityEngine.SceneManagement;
using System.Collections;

IEnumerator LoadLevel(string sceneName)
{
    // 1) Stream the level in alongside the Manager scene.
    yield return SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Additive);

    // 2) Make it the active scene so its lighting + new spawns apply.
    Scene level = SceneManager.GetSceneByName(sceneName);
    SceneManager.SetActiveScene(level);
}

yield return on the AsyncOperation is a tidy trick: a coroutine will pause on it until the load finishes, so line 2 only runs once the scene actually exists. Skip the wait and GetSceneByName may return an invalid scene.

Streaming Levels In & Out

Put it together and you get a clean level-swap: unload the old level, load the new one, activate it — all while the Manager and UI scenes never blink. Here's the lifecycle:

Figure 2: The streaming loop. The Manager and UI scenes load once and stay; level scenes are added and unloaded as the player progresses.

Notice the Manager scene loads with Single once at boot (clearing whatever came before), and everything after is additive. That guarantees exactly one Manager scene for the whole session.

Unloading with UnloadSceneAsync

Additive scenes don't clean themselves up — load ten levels additively without unloading and you'll have ten levels' worth of objects churning in memory. When you're done with a scene, release it with SceneManager.UnloadSceneAsync:

// Unload a specific level scene by name.
yield return SceneManager.UnloadSceneAsync("Level_1");

// Optional: reclaim the memory its assets used.
yield return Resources.UnloadUnusedAssets();

Two things to know:

• Unloading destroys that scene's GameObjects only. The other loaded scenes (Manager, UI) are untouched — that's the whole point.
• UnloadSceneAsync removes the objects, but the assets they referenced (textures, meshes) may linger. Call Resources.UnloadUnusedAssets() afterward to actually free that memory.

💡 There's an older name too. Long ago UnloadScene (synchronous) existed and is now deprecated. Always use UnloadSceneAsync — it spreads the teardown across frames just like async loading, so a big level unloads without a hitch.

DontDestroyOnLoad & Its Pitfall

There's a second way to keep something alive across scenes, and you'll see it everywhere: DontDestroyOnLoad. Call it on a GameObject and Unity moves it to a special hidden scene that survives every Single-mode load.

using UnityEngine;

public class GameManager : MonoBehaviour
{
    public static GameManager Instance { get; private set; }

    void Awake()
    {
        // Classic persistent-singleton guard.
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);   // a duplicate arrived — kill it
            return;
        }

        Instance = this;
        DontDestroyOnLoad(gameObject);   // survive scene loads
    }
}

The guard clause is not optional — it's the fix for the pitfall. Here's the trap:

So which do you reach for — a persistent Manager scene (Figure 1) or DontDestroyOnLoad on a single object?

• Manager scene (additive): visible in the Hierarchy, easy to inspect and edit, no hidden scene. Best when you have several persistent systems and use additive loading anyway.
• DontDestroyOnLoad: lightweight, works even with plain Single-mode loading, no extra scene to set up. Best for one or two singletons in a simpler project. Always pair it with the guard.

Hands-on Challenge

Summary

🚀 What's Next?

You can now move around a multi-scene game without losing your systems. But nothing you've done yet survives quitting — reload the game and every score, setting, and unlock is gone. In Lesson 5.3: Saving with PlayerPrefs we make small pieces of data stick between sessions.