Added a new additive scene manager to manage additive scenes. Yet to be tested in real application, but conceptually should work

Author: rkim-test

AdditiveSceneManager/AdditiveSceneManager.cs

@@ -2,34 +2,93 @@
 using System.Collections.Generic;
 using UnityEngine;
 using UnityEngine.SceneManagement;
-
-[System.Serializable]
-public class AdditiveSceneRef {
-    public string scene_name;
-    public Object scene_ref;
-}
+using UnityEngine.Events;
 
 public class AdditiveSceneManager : MonoBehaviour
 {
 
     // Global instance
     public static AdditiveSceneManager Instance;
+    
+    [Header("=== Scene Lists ===")]
+    [Tooltip("List of additive scenes. These scenes must be added to \"Build Settings\" too.")]
+    public Object[] scenes;
+    public Dictionary<string, Object> sceneDict;
+    private List<string> activeScenes = new List<string>();
 
-    // List of scenes
-    public AdditiveSceneRef[] scenes;
-
-    // Adictionary of scenes based on `scenes`; generated 
-
+    [Header("=== Callbacks ===")]
+    public UnityEvent onSceneLoadedCallback;
+    public UnityEvent onSceneUnloadedCallback;
 
     // Awake
     private void Awake() {
         Instance = this;
+        InitializeScenes();
+    }
+
+    private void InitializeScenes() {
+        // Load listeners
+        SceneManager.sceneLoaded += OnSceneLoaded;
+        SceneManager.sceneUnloaded += OnSceneUnloaded;
+
+        // Initialize arrays and dictionary
+        activeScenes = new List<string>();
+        sceneDict = new Dictionary<string, Object>();
+        foreach(Object s in scenes) {
+            sceneDict.Add(s.name, s);
+        }
     }
 
     // Add Scene from `scenes` to scene
-    public void AddScene(string quuery) {
+    public void LoadScene(string query, LoadSceneMode mode = LoadSceneMode.Additive) {
+        if(!sceneDict.ContainsKey(query)) {
+            Debug.LogError($"Query scene \"{query}\" doesn't exist in this scene manager!");
+            return;
+        }
+        if (activeScenes.Contains(query)) {
+            Debug.LogError($"Query scene \"{query}\" is already loaded additively. Will not add scene again.");
+            return;
+        }
+        SceneManager.LoadScene(sceneDict[query].name, mode);
+    }
+
+    public void UnloadScene(string query) {
+        if (!sceneDict.ContainsKey(query)) {
+            Debug.LogError($"Query scene \"{query}\" doesn't exist in this scene manager!");
+            return;
+        }
+        if (!activeScenes.Contains(query)) {
+            Debug.LogError($"Query scene \"{query}\" is not loaded.");
+            return;
+        }
+        SceneManager.UnloadSceneAsync(sceneDict[query].name);
+    }
+
+    public void OnSceneLoaded(Scene scene, LoadSceneMode mode) {
+        SceneManager.SetActiveScene(scene);
+        if (!activeScenes.Contains(scene.name)) activeScenes.Add(scene.name);
+        Debug.Log($"Scene \"{scene.name}\" loaded!");
+        onSceneLoadedCallback?.Invoke();
+    }
+
+    public void OnSceneUnloaded(Scene scene) {
+        if (activeScenes.Contains(scene.name)) activeScenes.Remove(scene.name);
+        Debug.Log($"Scene \"scene.name\" unloaded!");
+        onSceneUnloadedCallback?.Invoke();
+    }
+
+    public bool QuerySceneLoaded(string query) {
+        return activeScenes.Contains(query);
+    }
+
+    void OnDestroy() {
+        SceneManager.sceneLoaded -= OnSceneLoaded;
+        SceneManager.sceneUnloaded -= OnSceneUnloaded;
+    }
+
+
+
 
-    } 
 
 
 }

AdditiveSceneManager/Editor/AdditiveSceneManagerEditor.cs

@@ -0,0 +1,43 @@
+using UnityEngine;
+using UnityEditor;
+
+[CustomEditor(typeof(AdditiveSceneManager))]
+public class AdditiveSceneManagerEditor : Editor
+{
+    AdditiveSceneManager manager;
+
+    public void OnEnable() {
+        manager = (AdditiveSceneManager)target;
+    }
+
+    public override void OnInspectorGUI() {
+        DrawDefaultInspector();
+
+        // Don't do anything if not playing
+        if (!Application.isPlaying) return;
+
+        // Render controls for each scene
+        EditorGUILayout.LabelField("=== Scene Controls ===", EditorStyles.boldLabel);
+        foreach(Object s in manager.scenes) SceneButtons(s);
+    }
+
+    public void SceneButtons(Object s) {
+
+        // Query if scene is active
+        bool sceneActive = manager.QuerySceneLoaded(s.name);
+
+        // Start a horizontal group for the buttons
+        GUILayout.BeginHorizontal();
+
+        GUI.enabled = !sceneActive;
+        if (GUILayout.Button($"Load \"{s.name}\"")) manager.LoadScene(s.name);
+        GUI.enabled = sceneActive;
+        GUILayout.Space(5);
+        if (GUILayout.Button($"Unload \"{s.name}\"")) manager.UnloadScene(s.name);
+        GUI.enabled = true;
+
+        // End the horizontal group
+        GUILayout.EndHorizontal();
+    }
+
+}

README.md

@@ -54,4 +54,18 @@ The existing list of serialized equivalents of primitive Unity classes are:
 * `Color32` => `SColor32`
 * `RaycastHit` => `SRaycastHit`
 
-To use these serialized equivalents, you must import the namespace `using SerializableTypes`.
+To use these serialized equivalents, you must import the namespace `using SerializableTypes`.
+
+## Additive Scene Manager
+
+Included in this package is an `AdditiveSceneManager.cs` component. This component is a special helper to enable ADDITIVE scene management. I.E. allows you to load and unload scenes on top of another existing, single scene. Helpful for situations where you may want singleton logic at a scene level, by containing major components in the base scene and only switching out certain content dynamically.
+
+### Usage 
+
+Installation is really simple: just add `AdditiveSceneManager.cs` to any GameObject in your base scene, and populate the `Scenes` list with all the additive scenes.
+
+During runtime, if you are in the editor, you can debug how additive scenes load in via the Inspector; you can load and unload your additive scenes via some UI buttons we've added. You can also call the following functions to control loading and unloading:
+
+- `LoadScene(string scene_name, LoadSceneMode mode = LoadSceneMode.Additive)`: Loads a scene based on a string query. You CAN technically use this to load single scenes via the 2nd parameter, but this is not the intended function of this manager. **Only loads in scenes added to its `Scenes` list; doesn't control any scenes NOT added to that list.
+- `UnloadScene(string scene_name)`: Unloads a scene based on a string query. Only unloads a scene if 1) it's been added to the `Scenes` list of this manager, and 2) if it's loaded already. Doesn't do anything if the queried scene is unloaded already.
+- `QuerySceneLoaded(string scene_name)`: You can check if a scene has been additively loaded from this manager using this function. Returns a boolean indicating so.