Add coroutine-based scene loader

Author: joaoborks

Runtime/Interfaces/IAddressableSceneLoaderAsync.cs

@@ -38,7 +38,7 @@ public interface IAddressableSceneLoaderAsync : IAddressableSceneLoader
         /// or runtime key (<see cref="AddressableLoadSceneReferenceKey"/>).
         /// If null, the transition will not have an intermediate loading scene.
         /// </param>
-        /// <returns>The transition awaitable <see cref="Task{TResult}"/>"/> with the resulting <see cref="SceneInstance"/>.</returns>
+        /// <returns>The transition awaitable <see cref="Task{TResult}"/> with the resulting <see cref="SceneInstance"/>.</returns>
         Task<SceneInstance> TransitionToSceneAsync(IAddressableLoadSceneReference targetSceneReference, IAddressableLoadSceneReference intermediateSceneReference = null);
 
         /// <summary>
@@ -54,7 +54,7 @@ public interface IAddressableSceneLoaderAsync : IAddressableSceneLoader
         /// Should the loaded scene be marked as active?
         /// Equivalent to calling <see cref="IAddressableSceneManager.SetActiveSceneHandle(UnityEngine.ResourceManagement.AsyncOperations.AsyncOperationHandle{UnityEngine.ResourceManagement.ResourceProviders.SceneInstance})"/>.
         /// </param>
-        /// <returns>The load awaitable <see cref="Task{TResult}"/>"/> with the resulting <see cref="SceneInstance"/>.</returns>
+        /// <returns>The load awaitable <see cref="Task{TResult}"/> with the resulting <see cref="SceneInstance"/>.</returns>
         Task<SceneInstance> LoadSceneAsync(IAddressableLoadSceneReference sceneReference, bool setActive = false);
 
         /// <summary>

Runtime/Interfaces/IAddressableSceneLoaderCoroutine.cs

@@ -0,0 +1,72 @@
+#if ENABLE_ADDRESSABLES
+/**
+ * IAddressableSceneLoaderCoroutine.cs
+ * Created by: João Borks [joao.borks@gmail.com]
+ * Created on: 9/4/2022 (en-US)
+ */
+
+using UnityEngine;
+
+namespace MyUnityTools.SceneLoading.AddressablesSupport
+{
+    /// <summary>
+    /// Interface to standardize <see cref="Coroutine"/> addressable scene operations.
+    /// </summary>
+    public interface IAddressableSceneLoaderCoroutine : IAddressableSceneLoader
+    {
+        /// <summary>
+        /// Triggers a scene transition asynchronously.
+        /// It will transition from the current active scene (<see cref="IAddressableSceneManager.GetActiveSceneHandle"/>)
+        /// to the target scene (<paramref name="targetSceneReference"/>), with an optional intermediate loading scene (<paramref name="intermediateSceneReference"/>).
+        /// If the <paramref name="intermediateSceneReference"/> is not set, the transition will have no intermediate loading scene and will instead simply load the target scene directly.
+        /// The complete transition flow is:
+        /// <br/><br/>
+        /// 1. Load the intermediate scene (if provided).<br/>
+        /// 2. Load the target scene.<br/>
+        /// 3. Unload the intermediate scene (if provided).<br/>
+        /// 4. Unload the previous scene
+        /// </summary>
+        /// <param name="targetSceneReference">
+        /// The scene that's going to be transitioned to.
+        /// Can be the scene's addressable <see cref="UnityEngine.AddressableAssets.AssetReference"/> (<see cref="AddressableLoadSceneReferenceAsset"/>)
+        /// or runtime key (<see cref="AddressableLoadSceneReferenceKey"/>).
+        /// </param>
+        /// <param name="intermediateSceneReference">
+        /// The scene that's going to be loaded as the transition intermediate (as a loading scene).
+        /// Can be the scene's addressable <see cref="UnityEngine.AddressableAssets.AssetReference"/> (<see cref="AddressableLoadSceneReferenceAsset"/>)
+        /// or runtime key (<see cref="AddressableLoadSceneReferenceKey"/>).
+        /// If null, the transition will not have an intermediate loading scene.
+        /// </param>
+        /// <returns>The transition <see cref="Coroutine"/>.</returns>
+        Coroutine TransitionToSceneRoutine(IAddressableLoadSceneReference targetSceneReference, IAddressableLoadSceneReference intermediateSceneReference = null);
+
+        /// <summary>
+        /// Loads a scene additively asynchronously on top of the current scene stack, optionally marking it as the active scene
+        /// (<see cref="IAddressableSceneManager.SetActiveSceneHandle(UnityEngine.ResourceManagement.AsyncOperations.AsyncOperationHandle{UnityEngine.ResourceManagement.ResourceProviders.SceneInstance})"/>).
+        /// </summary>
+        /// <param name="sceneInfo">
+        /// The scene that's going to be loaded.
+        /// Can be the scene's addressable <see cref="UnityEngine.AddressableAssets.AssetReference"/> (<see cref="AddressableLoadSceneReferenceAsset"/>)
+        /// or runtime key (<see cref="AddressableLoadSceneReferenceKey"/>).
+        /// </param>
+        /// <param name="setActive">
+        /// Should the loaded scene be marked as active?
+        /// Equivalent to calling <see cref="IAddressableSceneManager.SetActiveSceneHandle(UnityEngine.ResourceManagement.AsyncOperations.AsyncOperationHandle{UnityEngine.ResourceManagement.ResourceProviders.SceneInstance})"/>.
+        /// </param>
+        /// <returns>The load <see cref="Coroutine"/>.</returns>
+        Coroutine LoadSceneRoutine(IAddressableLoadSceneReference sceneReference, bool setActive = false);
+
+        /// <summary>
+        /// Unloads the given scene asynchronously from the current scene stack.
+        /// </summary>
+        /// <param name="sceneInfo">
+        /// Target scene info.
+        /// Can be the scene's addressable <see cref="UnityEngine.ResourceManagement.AsyncOperations.AsyncOperationHandle{TObject}"/> (<see cref="AddressableLoadSceneInfoOperationHandle"/>),
+        /// its <see cref="UnityEngine.ResourceManagement.ResourceProviders.SceneInstance"/> (<see cref="AddressableLoadSceneInfoInstance"/>),
+        /// or its name (<see cref="AddressableLoadSceneInfoName"/>).
+        /// </param>
+        /// <returns>The unload awaitable <see cref="Coroutine"/>.</returns>
+        Coroutine UnloadSceneRoutine(IAddressableLoadSceneInfo sceneInfo);
+    }
+}
+#endif

Runtime/Interfaces/IAddressableSceneLoaderCoroutine.cs.meta

@@ -38,7 +38,7 @@ public interface IAddressableSceneLoaderUniTask : IAddressableSceneLoader
         /// or runtime key (<see cref="AddressableLoadSceneReferenceKey"/>).
         /// If null, the transition will not have an intermediate loading scene.
         /// </param>
-        /// <returns>The transition awaitable <see cref="UniTask{TResult}"/>"/> with the resulting <see cref="SceneInstance"/>.</returns>
+        /// <returns>The transition awaitable <see cref="UniTask{TResult}"/> with the resulting <see cref="SceneInstance"/>.</returns>
         UniTask<SceneInstance> TransitionToSceneAsync(IAddressableLoadSceneReference targetSceneReference, IAddressableLoadSceneReference intermediateSceneReference = null);
 
         /// <summary>
@@ -54,7 +54,7 @@ public interface IAddressableSceneLoaderUniTask : IAddressableSceneLoader
         /// Should the loaded scene be marked as active?
         /// Equivalent to calling <see cref="IAddressableSceneManager.SetActiveSceneHandle(UnityEngine.ResourceManagement.AsyncOperations.AsyncOperationHandle{UnityEngine.ResourceManagement.ResourceProviders.SceneInstance})"/>.
         /// </param>
-        /// <returns>The load awaitable <see cref="UniTask{TResult}"/>"/> with the resulting <see cref="SceneInstance"/>.</returns>
+        /// <returns>The load awaitable <see cref="UniTask{TResult}"/> with the resulting <see cref="SceneInstance"/>.</returns>
         UniTask<SceneInstance> LoadSceneAsync(IAddressableLoadSceneReference sceneReference, bool setActive = false);
 
         /// <summary>

Runtime/Interfaces/IAddressableSceneLoaderUniTask.cs

@@ -0,0 +1,62 @@
+/**
+ * ISceneLoaderCoroutine.cs
+ * Created by: João Borks [joao.borks@gmail.com]
+ * Created on: 9/4/2022 (en-US)
+ */
+
+using UnityEngine;
+
+namespace MyUnityTools.SceneLoading
+{
+    /// <summary>
+    /// Interface to standardize <see cref="Coroutine"/> scene operations.
+    /// </summary>
+    public interface ISceneLoaderCoroutine : ISceneLoader
+    {
+        /// <summary>
+        /// Triggers a scene transition asynchronously.
+        /// It will transition from the current active scene (<see cref="UnityEngine.SceneManagement.SceneManager.GetActiveScene()"/>)
+        /// to the target scene (<paramref name="targetSceneInfo"/>), with an optional intermediate loading scene (<paramref name="intermediateSceneInfo"/>).
+        /// If the <paramref name="intermediateSceneInfo"/> is not set, the transition will have no intermediate loading scene and will instead simply load the target scene directly.
+        /// The complete transition flow is:
+        /// <br/><br/>
+        /// 1. Load the intermediate scene (if provided).<br/>
+        /// 2. Load the target scene.<br/>
+        /// 3. Unload the intermediate scene (if provided).<br/>
+        /// 4. Unload the previous scene
+        /// </summary>
+        /// <param name="targetSceneInfo">
+        /// The scene that's going to be transitioned to.
+        /// Can be the scene's build index (<see cref="LoadSceneInfoIndex"/>) or name (<see cref="LoadSceneInfoName"/>).
+        /// </param>
+        /// <param name="intermediateSceneInfo">
+        /// The scene that's going to be loaded as the transition intermediate (as a loading scene).
+        /// Can be the scene's build index (<see cref="LoadSceneInfoIndex"/>) or name (<see cref="LoadSceneInfoName"/>).
+        /// If null, the transition will not have an intermediate loading scene.
+        /// </param>
+        /// <returns>The transition <see cref="Coroutine"/>.</returns>
+        Coroutine TransitionToSceneRoutine(ILoadSceneInfo targetSceneInfo, ILoadSceneInfo intermediateSceneInfo = null);
+
+        /// <summary>
+        /// Unloads the given scene asynchronously from the current scene stack.
+        /// </summary>
+        /// <param name="sceneInfo">
+        /// Target scene info.
+        /// Can be the scene's build index (<see cref="LoadSceneInfoIndex"/>) or name (<see cref="LoadSceneInfoName"/>).
+        /// </param>
+        /// <returns>The unload <see cref="Coroutine"/>.</returns>
+        Coroutine UnloadSceneRoutine(ILoadSceneInfo sceneInfo);
+
+        /// <summary>
+        /// Loads a scene additively on top of the current scene stack, optionally marking it as the active scene
+        /// (<see cref="UnityEngine.SceneManagement.SceneManager.SetActiveScene(UnityEngine.SceneManagement.Scene)"/>).
+        /// </summary>
+        /// <param name="sceneInfo">
+        /// The scene that's going to be loaded.
+        /// Can be the scene's build index (<see cref="LoadSceneInfoIndex"/>) or name (<see cref="LoadSceneInfoName"/>).
+        /// </param>
+        /// <param name="setActive">Should the loaded scene be marked as active? Equivalent to calling <see cref="UnityEngine.SceneManagement.SceneManager.SetActiveScene(UnityEngine.SceneManagement.Scene)"/>.</param>
+        /// <returns>The load awaitable <see cref="Coroutine"/>.</returns>
+        Coroutine LoadSceneRoutine(ILoadSceneInfo sceneInfo, bool setActive = false);
+    }
+}

Runtime/Interfaces/ISceneLoaderCoroutine.cs

@@ -42,12 +42,12 @@ public async Task<SceneInstance> LoadSceneAsync(IAddressableLoadSceneReference s
 
         public Task UnloadSceneAsync(IAddressableLoadSceneInfo sceneInfo) => sceneInfo.UnloadSceneAsync(_sceneManager).Task;
 
-        async Task<AsyncOperationHandle<SceneInstance>> LoadSceneAsyncWithReport(IAddressableLoadSceneReference sceneReference, SceneLoadProgressDelegate progressCallback)
+        async Task<AsyncOperationHandle<SceneInstance>> LoadSceneAsyncWithReport(IAddressableLoadSceneReference sceneReference, System.IProgress<float> progress)
         {
             var operation = sceneReference.LoadSceneAsync(_sceneManager);
             while (!operation.IsDone)
             {
-                progressCallback?.Invoke(operation.PercentComplete);
+                progress.Report(operation.PercentComplete);
                 await Task.Yield();
             }
             _sceneManager.SetActiveSceneHandle(operation);
@@ -67,7 +67,7 @@ async Task<SceneInstance> TransitionToSceneFlowAsync(IAddressableLoadSceneRefere
                 while (!loadingBehavior.Active)
                     await Task.Yield();
 
-                var operation = await LoadSceneAsyncWithReport(sceneReference, loadingBehavior.Report);
+                var operation = await LoadSceneAsyncWithReport(sceneReference, loadingBehavior);
                 loadingBehavior.CompleteLoading();
 
                 if (currentSceneHandle.IsValid())

Runtime/Interfaces/ISceneLoaderCoroutine.cs.meta

@@ -0,0 +1,101 @@
+#if ENABLE_ADDRESSABLES
+/**
+ * AddressableSceneLoaderCoroutine.cs
+ * Created by: João Borks [joao.borks@gmail.com]
+ * Created on: 9/4/2022 (en-US)
+ */
+
+using System.Collections;
+using UnityEngine;
+
+namespace MyUnityTools.SceneLoading.AddressablesSupport
+{
+    public class AddressableSceneLoaderCoroutine : IAddressableSceneLoaderCoroutine
+    {
+        public IAddressableSceneManager SceneManager => _sceneManager;
+
+        readonly IAddressableSceneManager _sceneManager;
+        readonly RoutineBehaviour _routineBehaviour;
+
+        public AddressableSceneLoaderCoroutine(IAddressableSceneManager sceneManager)
+        {
+            _sceneManager = sceneManager;
+            _routineBehaviour = RoutineBehaviour.Instance;
+        }
+
+        public void TransitionToScene(IAddressableLoadSceneReference targetSceneReference, IAddressableLoadSceneReference intermediateSceneReference) => TransitionToSceneRoutine(targetSceneReference, intermediateSceneReference);
+
+        public void LoadScene(IAddressableLoadSceneReference sceneReference, bool setActive) => LoadSceneRoutine(sceneReference, setActive);
+
+        public void UnloadScene(IAddressableLoadSceneInfo sceneInfo) => UnloadSceneRoutine(sceneInfo);
+
+        public Coroutine TransitionToSceneRoutine(IAddressableLoadSceneReference targetSceneReference, IAddressableLoadSceneReference intermediateSceneReference) => _routineBehaviour.StartCoroutine(intermediateSceneReference == null ? TransitionDirectlyRoutine(targetSceneReference) : TransitionWithIntermediateRoutine(targetSceneReference, intermediateSceneReference));
+
+        public Coroutine LoadSceneRoutine(IAddressableLoadSceneReference sceneReference, bool setActive) => _routineBehaviour.StartCoroutine(LoadRoutine(sceneReference, setActive));
+
+        public Coroutine UnloadSceneRoutine(IAddressableLoadSceneInfo sceneInfo) => _routineBehaviour.StartCoroutine(UnloadRoutine(sceneInfo));
+
+        IEnumerator LoadRoutine(IAddressableLoadSceneReference sceneReference, bool setActive)
+        {
+            var operation = sceneReference.LoadSceneAsync(_sceneManager);
+            yield return operation;
+            if (setActive)
+                _sceneManager.SetActiveSceneHandle(operation);
+        }
+
+        IEnumerator UnloadRoutine(IAddressableLoadSceneInfo sceneInfo)
+        {
+            yield return sceneInfo.UnloadSceneAsync(_sceneManager);
+        }
+
+        IEnumerator TransitionWithIntermediateRoutine(IAddressableLoadSceneReference targetSceneReference, IAddressableLoadSceneReference intermediateSceneReference)
+        {
+            var currentSceneHandle = _sceneManager.GetActiveSceneHandle();
+            var loadingSceneHandle = intermediateSceneReference.LoadSceneAsync(_sceneManager);
+            yield return loadingSceneHandle;
+            _sceneManager.SetActiveSceneHandle(loadingSceneHandle);
+
+            var loadingBehavior = Object.FindObjectOfType<LoadingBase>();
+            if (loadingBehavior)
+            {
+                yield return new WaitUntil(() => loadingBehavior.Active);
+
+                yield return LoadSceneRoutineWithReport(targetSceneReference, loadingBehavior);
+                loadingBehavior.CompleteLoading();
+
+                if (currentSceneHandle.IsValid())
+                    UnloadSceneRoutine(new AddressableLoadSceneInfoOperationHandle(currentSceneHandle));
+
+                yield return new WaitWhile(() => loadingBehavior.Active);
+
+                UnloadSceneRoutine(new AddressableLoadSceneInfoOperationHandle(loadingSceneHandle));
+            }
+            else
+            {
+                yield return LoadSceneRoutine(targetSceneReference, true);
+                if (currentSceneHandle.IsValid())
+                    UnloadSceneRoutine(new AddressableLoadSceneInfoOperationHandle(currentSceneHandle));
+                UnloadSceneRoutine(new AddressableLoadSceneInfoOperationHandle(loadingSceneHandle));
+            }
+        }
+
+        IEnumerator TransitionDirectlyRoutine(IAddressableLoadSceneReference targetSceneReference)
+        {
+            var currentSceneHandle = _sceneManager.GetActiveSceneHandle();
+            yield return LoadSceneRoutine(targetSceneReference, true);
+            UnloadSceneRoutine(new AddressableLoadSceneInfoOperationHandle(currentSceneHandle));
+        }
+
+        IEnumerator LoadSceneRoutineWithReport(IAddressableLoadSceneReference targetSceneReference, System.IProgress<float> progress)
+        {
+            var operation = targetSceneReference.LoadSceneAsync(_sceneManager);
+            while (!operation.IsDone)
+            {
+                progress.Report(operation.PercentComplete);
+                yield return null;
+            }
+            _sceneManager.SetActiveSceneHandle(operation);
+        }
+    }
+}
+#endif