Improve loading extensibility

Author: joaoborks

Runtime/Loading/LoadingBase.cs

@@ -0,0 +1,68 @@
+/**
+ * ILoading.cs
+ * Created by: João Borks [joao.borks@gmail.com]
+ * Created on: 9/3/2022 (en-US)
+ */
+
+using System;
+using UnityEngine;
+
+namespace MyUnityTools.SceneLoading
+{
+    /// <summary>
+    /// Base class to standardize the loading screen behavior.
+    /// Also implements <see cref="IProgress{T}"/>.
+    /// </summary>
+    public abstract class LoadingBase : MonoBehaviour, IProgress<float>
+    {
+        /// <summary>
+        /// Event that reports the scene load progression in percentage.
+        /// </summary>
+        public event SceneLoadProgressDelegate OnProgress;
+        /// <summary>
+        /// Event that reports when the loading has been completed.
+        /// </summary>
+        public event Action OnLoadingComplete;
+
+        /// <summary>
+        /// Controls if the loading screen is in an active state, in other words, if it's currently in focus.
+        /// This is required for the <see cref="ISceneLoader.TransitionToScene(ILoadSceneInfo, ILoadSceneInfo)"/> to know when it should perform its internal operations.
+        /// Before the loading screen can be actually seen, <see cref="Active"/> should be set to false.
+        /// For example, if the loading screen is being faded in, or if an animation is transitioning to it.
+        /// Then, once it's completely visible, <see cref="Active"/> should be set to true. The loading process starts.
+        /// Once the target scene has finished loading, then the loading screen gets faded out or transitions out.
+        /// After the transition has been completed and the loading screen is no longer visible, <see cref="Active"/>
+        /// should be set to false again.
+        /// </summary>
+        public bool Active { get; protected set; }
+
+        [SerializeField, Tooltip("Common scene operations stop at 90%, but addressable scene operations go all the way up to 100%. Enabling this value reduces the ratio to 90% instead of 100%")]
+        protected bool _reduceLoadRatio;
+
+        /// <summary>
+        /// Default ratio to consider when displaying the loading progress bar.
+        /// The <see cref="UnityEngine.SceneManagement.SceneManager"/> operations stop at 90%, so you might want to set that to 0.9f.
+        /// The addressable scene operations go all the way up to 100%.
+        /// </summary>
+        protected float _ratio = 1f;
+
+        protected virtual void Awake() => _ratio = _reduceLoadRatio ? .9f : 1f;
+
+        /// <summary>
+        /// Reports that the loading of the target scene has been completed, and the loading view can transition out of the screen.
+        /// </summary>
+        public virtual void CompleteLoading() => OnLoadingComplete?.Invoke();
+
+        /// <summary>
+        /// Reports the current scene load progression in percentage.
+        /// </summary>
+        /// <param name="progress">The percentage of the scene load progression.</param>
+        public virtual void Report(float progress) => OnProgress?.Invoke(progress / _ratio);
+    }
+
+    /// <summary>
+    /// Delegate to propagate the scene load progress in percentage.
+    /// </summary>
+    /// <param name="progress">The percentage value of the load progression from 0 to 1.</param>
+    public delegate void SceneLoadProgressDelegate(float progress);
+}

Runtime/Loading/LoadingBase.cs.meta

@@ -4,30 +4,16 @@
  * Created on: 7/23/2022 (en-US)
  */
 
-using System;
 using UnityEngine;
 
 namespace MyUnityTools.SceneLoading
 {
-    public delegate void SceneLoadProgressDelegate(float progress);
-    
-    public class LoadingBehavior : MonoBehaviour, IProgress<float>
+    public class LoadingBehavior : LoadingBase
     {
-        public event SceneLoadProgressDelegate OnProgress;
-        public event Action OnLoadingComplete;
-
-        public bool Active { get; private set; }
-
-        [SerializeField]
+        [SerializeField, Tooltip("Should it wait for an animation or script to allow starting the transition? If not, then enable this toggle.")]
         bool _autoStart;
-        [SerializeField]
+        [SerializeField, Tooltip("Should it wait for an animation or script to allow finishing the transition? If not, then enable this toggle.")]
         bool _autoFinish;
-        [SerializeField]
-        bool _reduceLoadRatio;
-
-        float _ratio;
-
-        void Awake() => _ratio = _reduceLoadRatio ? .9f : 1f;
 
         void Start()
         {
@@ -37,13 +23,11 @@ void Start()
 
         public void SetLoadingActive(bool value) => Active = value;
 
-        public void CompleteLoading()
+        public override void CompleteLoading()
         {
-            OnLoadingComplete?.Invoke();
+            base.CompleteLoading();
             if (_autoFinish)
                 SetLoadingActive(false);
         }
-
-        public void Report(float progress) => OnProgress?.Invoke(progress / _ratio);
     }
 }

Runtime/Loading/LoadingBehavior.cs

@@ -58,7 +58,7 @@ async Task<SceneInstance> TransitionToSceneFlowAsync(IAddressableLoadSceneRefere
         {
             var currentSceneHandle = _sceneManager.GetActiveSceneHandle();
             var loadingScene = await intermediateSceneReference.LoadSceneAsync(_sceneManager).Task;
-            var loadingBehavior = Object.FindObjectOfType<LoadingBehavior>();
+            var loadingBehavior = Object.FindObjectOfType<LoadingBase>();
 
             SceneInstance result;
 
@@ -82,7 +82,8 @@ async Task<SceneInstance> TransitionToSceneFlowAsync(IAddressableLoadSceneRefere
             else
             {
                 result = await LoadSceneAsync(sceneReference, true);
-                _ = UnloadSceneAsync(new AddressableLoadSceneInfoOperationHandle(currentSceneHandle));
+                if (currentSceneHandle.IsValid())
+                    _ = UnloadSceneAsync(new AddressableLoadSceneInfoOperationHandle(currentSceneHandle));
                 _ = UnloadSceneAsync(new AddressableLoadSceneInfoInstance(loadingScene));
             }
             return result;

Runtime/SceneLoaders/AddressableSceneLoaderAsync.cs

@@ -54,7 +54,7 @@ async UniTask<SceneInstance> TransitionToSceneFlowAsync(IAddressableLoadSceneRef
         {
             var currentSceneHandle = _sceneManager.GetActiveSceneHandle();
             var loadingScene = await intermediateSceneReference.LoadSceneAsync(_sceneManager).Task;
-            var loadingBehavior = Object.FindObjectOfType<LoadingBehavior>();
+            var loadingBehavior = Object.FindObjectOfType<LoadingBase>();
 
             SceneInstance result;
 
@@ -77,7 +77,8 @@ async UniTask<SceneInstance> TransitionToSceneFlowAsync(IAddressableLoadSceneRef
             else
             {
                 result = await LoadSceneAsync(sceneReference, true);
-                UnloadSceneAsync(new AddressableLoadSceneInfoOperationHandle(currentSceneHandle)).Forget();
+                if (currentSceneHandle.IsValid())
+                    UnloadSceneAsync(new AddressableLoadSceneInfoOperationHandle(currentSceneHandle)).Forget();
                 UnloadSceneAsync(new AddressableLoadSceneInfoInstance(loadingScene)).Forget();
             }
             return result;

Runtime/SceneLoaders/AddressableSceneLoaderUniTask.cs

@@ -42,7 +42,7 @@ async Task TransitionWithIntermediateAsync(ILoadSceneInfo targetSceneInfo, ILoad
             var currentSceneInfo = new LoadSceneInfoIndex(SceneManager.GetActiveScene().buildIndex);
             await LoadSceneAsync(intermediateSceneInfo, true);
 
-            var loadingBehavior = Object.FindObjectOfType<LoadingBehavior>();
+            var loadingBehavior = Object.FindObjectOfType<LoadingBase>();
             if (loadingBehavior)
             {
                 while (!loadingBehavior.Active)

Runtime/SceneLoaders/SceneLoaderAsync.cs

@@ -36,7 +36,7 @@ async UniTask TransitionWithIntermediateAsync(ILoadSceneInfo targetSceneInfo, IL
             var currentSceneInfo = new LoadSceneInfoIndex(SceneManager.GetActiveScene().buildIndex);
             await LoadSceneAsync(intermediateSceneInfo, true);
 
-            var loadingBehavior = Object.FindObjectOfType<LoadingBehavior>();
+            var loadingBehavior = Object.FindObjectOfType<LoadingBase>();
             if (loadingBehavior)
             {
                 await UniTask.WaitWhile(() => !loadingBehavior.Active);