SceneManager

Description

Manage scenes in the Player and in Play mode in the Editor.

You can use the SceneManager to manage and manipulate scenes in the Player.

Scene creation, loading and unloading

• To create scenes dynamically at runtime, use SceneManager.CreateScene.
• To load scenes from built content, use SceneManager.LoadSceneAsync or SceneManager.LoadScene.
• Scenes cannot be saved at runtime.
• You can load multiple scenes simultaneously. To add more scenes to the currently open ones, use the LoadSceneMode.Additive option when calling SceneManager.LoadSceneAsync or SceneManager.LoadScene.
• You can load the same scene multiple times in both the Player and in Play mode in the Editor. In Edit mode in the Editor, SceneManager cannot be used and a scene can only be loaded once (using EditorSceneManager).
• To unload a scene explicitly, use SceneManager.UnloadSceneAsync. All open scenes can be unloaded implicitly by loading another scene with LoadSceneMode.Single.

Accessing loaded scenes

The Scene Manager offers APIs to access currently loaded Scenes. For example, SceneManager.loadedSceneCount, SceneManager.GetSceneAt, and SceneManager.GetSceneByPath.

Scene manipulation

To move objects between scenes, use methods like SceneManager.MergeScenes and SceneManager.MoveGameObjectToScene.

SceneManager events

The SceneManager also exposes the following events:

• SceneManager.activeSceneChanged
• SceneManager.sceneLoaded
• SceneManager.sceneUnloaded

Scripts can register on these events and then be notified when there are changes in the state of the SceneManager.

The scene list

The Player contains a BuildSettings object which records the list of scenes that are available to load. The contents of this list is exposed by SceneManager.sceneCountInBuildSettings and SceneUtility.GetScenePathByBuildIndex.

The contents of this list is determined when the Player is built:

• By default, all the enabled scenes in the EditorBuildSettings.scenes array are included. You can view and edit this list from the active profile in the Build Profiles window.
• When building via scripts with BuildPipeline.BuildPlayer, specify scenes using BuildPlayerOptions.scenes.

The scene order is crucial for several reasons:

• The first enabled scene in the Scene list (with a build index of 0) loads automatically when the Player starts.
• Earlier listed Scenes load faster due to optimized assignment of their dependent content to fewer sharedAsset files.
• SceneManager.LoadSceneAsync and SceneManager.LoadScene supports loading scenes by index, determined by the order in EditorBuildSettings.scenes or BuildPlayerOptions.scenes after any disabled scenes are removed.

AssetBundles and Scenes

• Additional scenes can be included in AssetBundles. When an AssetBundle that contains scenes is loaded, its scenes become available to the SceneManager and can be loaded by path using SceneManager.LoadSceneAsync or SceneManager.LoadScene.
• Scenes from AssetBundles have a Scene.buildIndex of -1.
• When loading scenes by path, a match from loaded AssetBundle takes priority over scenes in the Player build.

Scene management in the Editor

• Use EditorSceneManager instead of SceneManager for scene authoring and manipulation in the Editor.
• The SceneManager API should only be used in Play mode. In Edit mode calls to unsupported methods such as SceneManager.LoadSceneAsync will throw an invalid operation exception.
• In Play mode, only scenes listed in EditorBuildSettings are available to load, along with scenes from loaded AssetBundles, simulating Player behavior.

Notes

• Loading Scenes by index can be fragile due to potential reordering; the recommended best practice is to load scenes by path for better clarity.
• Loading scenes by filename (without a full path) can cause issues if multiple scenes share the same name; full path specification removes that ambiguity.

Additional resources: EditorSceneManager, SceneUtility, Scene.buildIndex, EditorBuildSettingsScene.enabled, AssetBundle.GetAllScenePaths.

using UnityEngine;
using UnityEngine.SceneManagement;

// This MonoBehaviour could be placed as a component inside the first scene in the Build Profiles Scene List.
// When the Player starts it instantiates this MonoBehaviour, which in turn loads
// an additional scene.
public class SceneLoader : MonoBehaviour
{
    // This scene must be listed in the Scene List in the Build Profiles Window,
    // or available from a loaded AssetBundle.
    const string sceneToLoad = "Assets/Example/AnotherScene.unity";

    void Start()
    {
        var op = SceneManager.LoadSceneAsync(sceneToLoad, LoadSceneMode.Additive);
        op.completed += (AsyncOperation obj) =>
        {
            Scene loadedScene = SceneManager.GetSceneByPath(sceneToLoad);
            Debug.Log($"{sceneToLoad} finished loading (build index: {loadedScene.buildIndex}).");
            Debug.Log($"It has {loadedScene.rootCount} root(s).");
            Debug.Log($"There are now {SceneManager.loadedSceneCount} Scenes open.");
        };
    }

    private void OnDestroy()
    {
        // When closing the Scene containing this MonoBehaviour we also remove the Scene we loaded
        SceneManager.UnloadSceneAsync(sceneToLoad);
    }
}

using System.Text;
using UnityEngine;
using UnityEngine.SceneManagement;

public class SceneInfo : MonoBehaviour
{
    void Start()
    {
        LogSceneManagerState();
    }

    void LogSceneManagerState()
    {
        var sb = new StringBuilder();
        sb.AppendLine("SceneManager state");

        sb.AppendLine($"Active Scene: {SceneManager.GetActiveScene().path}");

        sb.AppendLine($"Scene List (size {SceneManager.sceneCountInBuildSettings})");
        for(int i = 0; i < SceneManager.sceneCountInBuildSettings; i++)
        {
            var scenePath = SceneUtility.GetScenePathByBuildIndex(i);
            sb.AppendLine($"  {i}: {scenePath}");
        }

        sb.AppendLine($"Loaded Scenes (size {SceneManager.sceneCount})");
        for(int i = 0; i < SceneManager.sceneCount; i++)
        {
            var scene = SceneManager.GetSceneAt(i);
            sb.AppendLine($"  {i}: {scene.path}");
        }

        Debug.Log(sb.ToString());
    }
}

Static Properties

Static Methods

Events