add reload scene methods and tests

Author: joaoborks

Packages/com.mygamedevtools.scene-loader/Runtime/CoreSceneManager.cs

@@ -147,6 +147,15 @@ public Task<SceneResult> TransitionAsync(SceneParameters sceneParameters, ILoadS
                 : TransitionWithIntermediateAsync(sceneParameters, intermediateSceneReference, linkedSource.Token).RunAndDisposeToken(linkedSource);
         }
 
+        public Task<SceneResult> ReloadActiveSceneAsync(ILoadSceneInfo intermediateSceneReference = null, CancellationToken token = default)
+        {
+            if (_activeScene == null || !_activeScene.SceneReference.IsValid() || !_activeScene.SceneReference.isLoaded)
+                throw new InvalidOperationException($"[{GetType().Name}] Cannot reload the active scene because it is null or not loaded. Make sure to load a scene before trying to reload it.");
+
+            ILoadSceneInfo targetSceneInfo = _activeScene.LoadSceneInfo;
+            return TransitionAsync(new SceneParameters(targetSceneInfo, true), intermediateSceneReference, token);
+        }
+
         public Task<SceneResult> LoadAsync(SceneParameters sceneParameters, IProgress<float> progress = null, CancellationToken token = default)
         {
             CancellationTokenSource linkedSource = CancellationTokenSource.CreateLinkedTokenSource(_lifetimeTokenSource.Token, token);

Packages/com.mygamedevtools.scene-loader/Runtime/Interfaces/ISceneManager.cs

@@ -69,6 +69,17 @@ public interface ISceneManager : IDisposable
         /// <returns>A <see cref="System.Threading.Tasks.Task{TResult}"/> with all scenes loaded.</returns>
         Task<SceneResult> TransitionAsync(SceneParameters sceneParameters, ILoadSceneInfo intermediateSceneReference = default, CancellationToken token = default);
 
+        /// <summary>
+        /// Reloads the active scene with an optional intermediate loading scene.
+        /// </summary>
+        /// <param name="intermediateSceneReference">
+        /// A reference to the scene that's going to be loaded as the transition intermediate (as a loading scene).
+        /// If null, the transition will not have an intermediate loading scene.
+        /// </param>
+        /// <param name="token">Optional token to manually cancel the operation. Note that Unity Scene Manager operations cannot be manually canceled and will continue to run.</param>
+        /// <returns>A <see cref="System.Threading.Tasks.Task{TResult}"/> with all scenes reloaded.</returns>
+        Task<SceneResult> ReloadActiveSceneAsync(ILoadSceneInfo intermediateSceneReference = default, CancellationToken token = default);
+
         /// <summary>
         /// Loads the target scene or group of scenes provided via a <see cref="SceneParameters"/> struct.
         /// You may also provide the desired index to set as the active scene.

Packages/com.mygamedevtools.scene-loader/Runtime/MySceneManager.cs

@@ -100,6 +100,17 @@ public static event Action<Scene> SceneLoaded
         /// <returns>A <see cref="System.Threading.Tasks.Task{TResult}"/> with all scenes loaded.</returns>
         public static Task<SceneResult> TransitionAsync(SceneParameters sceneParameters, ILoadSceneInfo intermediateSceneReference = default, CancellationToken token = default) => Instance.TransitionAsync(sceneParameters, intermediateSceneReference, token);
 
+        /// <summary>
+        /// Reloads the active scene with an optional intermediate loading scene.
+        /// </summary>
+        /// <param name="intermediateSceneReference">
+        /// A reference to the scene that's going to be loaded as the transition intermediate (as a loading scene).
+        /// If null, the transition will not have an intermediate loading scene.
+        /// </param>
+        /// <param name="token">Optional token to manually cancel the operation. Note that Unity Scene Manager operations cannot be manually canceled and will continue to run.</param>
+        /// <returns>A <see cref="System.Threading.Tasks.Task{TResult}"/> with all scenes reloaded.</returns>
+        public static Task<SceneResult> ReloadActiveSceneAsync(ILoadSceneInfo intermediateSceneReference = null, CancellationToken token = default) => Instance.ReloadActiveSceneAsync(intermediateSceneReference, token);
+
         /// <summary>
         /// Loads the target scene or group of scenes provided via a <see cref="SceneParameters"/> struct.
         /// You may also provide the desired index to set as the active scene.
@@ -520,6 +531,52 @@ public static event Action<Scene> SceneLoaded
         public static Task<SceneResult> TransitionAddressableAsync(string targetAddress, string loadingAddress = null, CancellationToken token = default) => Instance.TransitionAddressableAsync(targetAddress, loadingAddress, token);
 #endif
 
+        /// <summary>
+        /// Reloads the active scene with an optional intermediate loading scene.
+        /// </summary>
+        /// <param name="loadingSceneName">
+        /// A reference to the scene that's going to be loaded as the transition intermediate (as a loading scene).
+        /// If null, the transition will not have an intermediate loading scene.
+        /// </param>
+        /// <param name="token">Optional token to manually cancel the operation. Note that Unity Scene Manager operations cannot be manually canceled and will continue to run.</param>
+        /// <returns>A <see cref="System.Threading.Tasks.Task{TResult}"/> with all scenes reloaded.</returns>
+        public static Task<SceneResult> ReloadActiveSceneAsync(string loadingSceneName = null, CancellationToken token = default) => Instance.ReloadActiveSceneAsync(loadingSceneName, token);
+
+        /// <summary>
+        /// Reloads the active scene with an optional intermediate loading scene.
+        /// </summary>
+        /// <param name="loadingBuildIndex">
+        /// A reference to the scene that's going to be loaded as the transition intermediate (as a loading scene).
+        /// If null, the transition will not have an intermediate loading scene.
+        /// </param>
+        /// <param name="token">Optional token to manually cancel the operation. Note that Unity Scene Manager operations cannot be manually canceled and will continue to run.</param>
+        /// <returns>A <see cref="System.Threading.Tasks.Task{TResult}"/> with all scenes reloaded.</returns>
+        public static Task<SceneResult> ReloadActiveSceneAsync(int loadingBuildIndex = -1, CancellationToken token = default) => Instance.ReloadActiveSceneAsync(loadingBuildIndex, token);
+
+#if ENABLE_ADDRESSABLES
+        /// <summary>
+        /// Reloads the active scene with an optional intermediate loading scene.
+        /// </summary>
+        /// <param name="loadingAssetReference">
+        /// A reference to the scene that's going to be loaded as the transition intermediate (as a loading scene).
+        /// If null, the transition will not have an intermediate loading scene.
+        /// </param>
+        /// <param name="token">Optional token to manually cancel the operation. Note that Unity Scene Manager operations cannot be manually canceled and will continue to run.</param>
+        /// <returns>A <see cref="System.Threading.Tasks.Task{TResult}"/> with all scenes reloaded.</returns>
+        public static Task<SceneResult> ReloadActiveSceneAddressableAsync(AssetReference loadingAssetReference = null, CancellationToken token = default) => Instance.ReloadActiveSceneAddressableAsync(loadingAssetReference, token);
+
+        /// <summary>
+        /// Reloads the active scene with an optional intermediate loading scene.
+        /// </summary>
+        /// <param name="loadingAddress">
+        /// A reference to the scene that's going to be loaded as the transition intermediate (as a loading scene).
+        /// If null, the transition will not have an intermediate loading scene.
+        /// </param>
+        /// <param name="token">Optional token to manually cancel the operation. Note that Unity Scene Manager operations cannot be manually canceled and will continue to run.</param>
+        /// <returns>A <see cref="System.Threading.Tasks.Task{TResult}"/> with all scenes reloaded.</returns>
+        public static Task<SceneResult> ReloadActiveSceneAddressableAsync(string loadingAddress = null, CancellationToken token = default) => Instance.ReloadActiveSceneAddressableAsync(loadingAddress, token);
+#endif
+
         /// <summary>
         /// Unloads the target scene or group of scenes.
         /// </summary>

Packages/com.mygamedevtools.scene-loader/Runtime/Utilities/SceneManagerExtensions.cs

@@ -447,6 +447,68 @@ public static Task<SceneResult> TransitionAddressableAsync(this ISceneManager sc
         }
 #endif
 
+        /// <summary>
+        /// Reloads the active scene with an optional intermediate loading scene.
+        /// </summary>
+        /// <param name="loadingSceneName">
+        /// A reference to the scene that's going to be loaded as the transition intermediate (as a loading scene).
+        /// If null, the transition will not have an intermediate loading scene.
+        /// </param>
+        /// <param name="token">Optional token to manually cancel the operation. Note that Unity Scene Manager operations cannot be manually canceled and will continue to run.</param>
+        /// <returns>A <see cref="System.Threading.Tasks.Task{TResult}"/> with all scenes reloaded.</returns>
+        public static Task<SceneResult> ReloadActiveSceneAsync(this ISceneManager sceneManager, string loadingSceneName = null, CancellationToken token = default)
+        {
+            ILoadSceneInfo loadingSceneInfo = string.IsNullOrWhiteSpace(loadingSceneName) ? null : new LoadSceneInfoName(loadingSceneName);
+            return sceneManager.ReloadActiveSceneAsync(loadingSceneInfo, token);
+        }
+
+        /// <summary>
+        /// Reloads the active scene with an optional intermediate loading scene.
+        /// </summary>
+        /// <param name="loadingBuildIndex">
+        /// A reference to the scene that's going to be loaded as the transition intermediate (as a loading scene).
+        /// If null, the transition will not have an intermediate loading scene.
+        /// </param>
+        /// <param name="token">Optional token to manually cancel the operation. Note that Unity Scene Manager operations cannot be manually canceled and will continue to run.</param>
+        /// <returns>A <see cref="System.Threading.Tasks.Task{TResult}"/> with all scenes reloaded.</returns>
+        public static Task<SceneResult> ReloadActiveSceneAsync(this ISceneManager sceneManager, int loadingBuildIndex = -1, CancellationToken token = default)
+        {
+            ILoadSceneInfo loadingSceneInfo = loadingBuildIndex >= 0 ? new LoadSceneInfoIndex(loadingBuildIndex) : null;
+            return sceneManager.ReloadActiveSceneAsync(loadingSceneInfo, token);
+        }
+
+#if ENABLE_ADDRESSABLES
+        /// <summary>
+        /// Reloads the active scene with an optional intermediate loading scene.
+        /// </summary>
+        /// <param name="loadingAssetReference">
+        /// A reference to the scene that's going to be loaded as the transition intermediate (as a loading scene).
+        /// If null, the transition will not have an intermediate loading scene.
+        /// </param>
+        /// <param name="token">Optional token to manually cancel the operation. Note that Unity Scene Manager operations cannot be manually canceled and will continue to run.</param>
+        /// <returns>A <see cref="System.Threading.Tasks.Task{TResult}"/> with all scenes reloaded.</returns>
+        public static Task<SceneResult> ReloadActiveSceneAddressableAsync(this ISceneManager sceneManager, AssetReference loadingAssetReference = null, CancellationToken token = default)
+        {
+            ILoadSceneInfo loadingSceneInfo = loadingAssetReference != null ? new LoadSceneInfoAssetReference(loadingAssetReference) : null;
+            return sceneManager.ReloadActiveSceneAsync(loadingSceneInfo, token);
+        }
+
+        /// <summary>
+        /// Reloads the active scene with an optional intermediate loading scene.
+        /// </summary>
+        /// <param name="loadingAddress">
+        /// A reference to the scene that's going to be loaded as the transition intermediate (as a loading scene).
+        /// If null, the transition will not have an intermediate loading scene.
+        /// </param>
+        /// <param name="token">Optional token to manually cancel the operation. Note that Unity Scene Manager operations cannot be manually canceled and will continue to run.</param>
+        /// <returns>A <see cref="System.Threading.Tasks.Task{TResult}"/> with all scenes reloaded.</returns>
+        public static Task<SceneResult> ReloadActiveSceneAddressableAsync(this ISceneManager sceneManager, string loadingAddress = null, CancellationToken token = default)
+        {
+            ILoadSceneInfo loadingSceneInfo = string.IsNullOrWhiteSpace(loadingAddress) ? null : new LoadSceneInfoAddress(loadingAddress);
+            return sceneManager.ReloadActiveSceneAsync(loadingSceneInfo, token);
+        }
+#endif
+
         /// <summary>
         /// Unloads the target scene or group of scenes.
         /// </summary>

Packages/com.mygamedevtools.scene-loader/Tests/Runtime/SceneManagerTests.cs

@@ -238,6 +238,12 @@ public void Unload_NotLoaded([ValueSource(typeof(SceneTestEnvironment), nameof(S
             Assert.Throws<AggregateException>(() => wait.MoveNext());
         }
 
+        [UnityTest]
+        public IEnumerator Reload([ValueSource(typeof(SceneTestEnvironment), nameof(SceneTestEnvironment.SceneManagers))] ISceneManager manager, [ValueSource(typeof(SceneTestEnvironment), nameof(SceneTestEnvironment.SingleLoadSceneInfoList))] ILoadSceneInfo loadSceneInfo, [ValueSource(nameof(LoadingSceneInfos))] ILoadSceneInfo loadingScene)
+        {
+            yield return Reload_Template(manager, loadSceneInfo, () => manager.ReloadActiveSceneAsync(loadingScene));
+        }
+
         [UnityTest]
         public IEnumerator Transition([ValueSource(typeof(SceneTestEnvironment), nameof(SceneTestEnvironment.SceneManagers))] ISceneManager manager, [ValueSource(typeof(SceneTestEnvironment), nameof(SceneTestEnvironment.
         TransitionSceneParametersList))] SceneParameters sceneParameters, [ValueSource(nameof(LoadingSceneInfos))] ILoadSceneInfo loadingScene)
@@ -367,6 +373,21 @@ public IEnumerator Load_Template(ISceneManager manager, Func<Task<SceneResult>>
             void reportSceneLoaded(Scene loadedScene) => reportedScenes.Add(loadedScene);
         }
 
+        public IEnumerator Reload_Template(ISceneManager manager, ILoadSceneInfo loadSceneInfo, Func<Task<SceneResult>> reloadTask)
+        {
+            yield return manager.LoadAsync(new SceneParameters(loadSceneInfo, true)).ToWaitTask();
+            string activeScene = manager.GetActiveScene().name;
+
+            var task = reloadTask();
+            yield return task.ToWaitTask();
+
+            Scene loadedScene = task.Result;
+            Assert.AreEqual(manager.GetActiveScene(), loadedScene);
+            Assert.AreEqual(activeScene, loadedScene.name);
+
+            yield return new WaitUntil(() => manager.TotalSceneCount == 1);
+        }
+
         public IEnumerator Transition_Template(ISceneManager manager, Func<Task<SceneResult>> transitionTask, int sceneCount, int setIndexActive)
         {
             yield return LoadFirstScene(manager);

Packages/com.mygamedevtools.scene-loader/Tests/Runtime/SceneManager_AssetReferenceTests.cs

@@ -41,6 +41,12 @@ public IEnumerator Load_AssetReference([ValueSource(typeof(SceneTestEnvironment)
             yield return Load(manager, new SceneParameters(_assetReferenceLoadSceneInfos, setIndexActive));
         }
 
+        [UnityTest]
+        public IEnumerator Reload_AssetReference([ValueSource(typeof(SceneTestEnvironment), nameof(SceneTestEnvironment.SceneManagers))] ISceneManager manager, [ValueSource(nameof(LoadingSceneInfos))] ILoadSceneInfo loadingScene)
+        {
+            yield return Reload(manager, _assetReferenceLoadSceneInfos[0], loadingScene);
+        }
+
         [UnityTest]
         public IEnumerator Unload_AssetReference([ValueSource(typeof(SceneTestEnvironment), nameof(SceneTestEnvironment.SceneManagers))] ISceneManager manager)
         {

Packages/com.mygamedevtools.scene-loader/Tests/Runtime/SceneManager_ExtensionTests.cs

@@ -117,6 +117,32 @@ public IEnumerator Transition_Extension_Addressable_ByAssetReference_Multiple([V
         }
 #endif
 
+        [UnityTest]
+        public IEnumerator Reload_Extension_ByName([ValueSource(typeof(SceneTestEnvironment), nameof(SceneTestEnvironment.SceneManagers))] ISceneManager manager)
+        {
+            yield return Reload_Template(manager, new LoadSceneInfoName(SceneBuilder.SceneNames[1]), () => manager.ReloadActiveSceneAsync(SceneBuilder.SceneNames[1]));
+        }
+
+        [UnityTest]
+        public IEnumerator Reload_Extension_ByIndex([ValueSource(typeof(SceneTestEnvironment), nameof(SceneTestEnvironment.SceneManagers))] ISceneManager manager)
+        {
+            yield return Reload_Template(manager, new LoadSceneInfoIndex(1), () => manager.ReloadActiveSceneAsync(1));
+        }
+
+#if ENABLE_ADDRESSABLES
+        [UnityTest]
+        public IEnumerator Reload_Extension_Addressable_ByAddress([ValueSource(typeof(SceneTestEnvironment), nameof(SceneTestEnvironment.SceneManagers))] ISceneManager manager)
+        {
+            yield return Reload_Template(manager, new LoadSceneInfoAddress(SceneBuilder.SceneNames[1]), () => manager.ReloadActiveSceneAddressableAsync(SceneBuilder.SceneNames[1]));
+        }
+
+        [UnityTest]
+        public IEnumerator Reload_Extension_Addressable_ByAssetReference([ValueSource(typeof(SceneTestEnvironment), nameof(SceneTestEnvironment.SceneManagers))] ISceneManager manager)
+        {
+            yield return Reload_Template(manager, new LoadSceneInfoAssetReference(_assetReferences[1]), () => manager.ReloadActiveSceneAddressableAsync(_assetReferences[1]));
+        }
+#endif
+
         [UnityTest]
         public IEnumerator Unload_Extension_ByIndex([ValueSource(typeof(SceneTestEnvironment), nameof(SceneTestEnvironment.SceneManagers))] ISceneManager manager)
         {

Packages/com.mygamedevtools.scene-loader/Tests/Runtime/StaticSceneManager_ExtensionTests.cs

@@ -137,6 +137,32 @@ public IEnumerator Transition_Extension_Addressable_ByAssetReference_Multiple()
         }
 #endif
 
+        [UnityTest]
+        public IEnumerator Reload_Extension_ByName()
+        {
+            yield return Reload_Template(new LoadSceneInfoName(SceneBuilder.SceneNames[1]), () => MySceneManager.ReloadActiveSceneAsync(SceneBuilder.SceneNames[1]));
+        }
+
+        [UnityTest]
+        public IEnumerator Reload_Extension_ByIndex()
+        {
+            yield return Reload_Template(new LoadSceneInfoIndex(1), () => MySceneManager.ReloadActiveSceneAsync(1));
+        }
+
+#if ENABLE_ADDRESSABLES
+        [UnityTest]
+        public IEnumerator Reload_Extension_Addressable_ByAddress()
+        {
+            yield return Reload_Template(new LoadSceneInfoAddress(SceneBuilder.SceneNames[1]), () => MySceneManager.ReloadActiveSceneAddressableAsync(SceneBuilder.SceneNames[1]));
+        }
+
+        [UnityTest]
+        public IEnumerator Reload_Extension_Addressable_ByAssetReference()
+        {
+            yield return Reload_Template(new LoadSceneInfoAssetReference(_assetReferences[1]), () => MySceneManager.ReloadActiveSceneAddressableAsync(_assetReferences[1]));
+        }
+#endif
+
         [UnityTest]
         public IEnumerator Unload_Extension_ByIndex()
         {