Merge pull request #26 from mewlist/refactoring

Refactoring

Runtime/Assets/Compatibility/CompatibleSceneLoader.cs

@@ -0,0 +1,32 @@
+using System.Threading.Tasks;
+using Mew.Core.TaskHelpers;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace Mew.Core.Assets
+{
+    internal static class CompatibleSceneLoader
+    {
+        internal static async ValueTask<SceneHandle> LoadSceneAsync(UnifiedScene unifiedScene, LoadSceneParameters parameters)
+        {
+#if UNITY_2023_2_OR_NEWER
+            await SceneManager.LoadSceneAsync(unifiedScene.SceneReference, parameters);
+#else
+                var asyncOp = SceneManager.LoadSceneAsync(unifiedScene.SceneReference, parameters);
+                while (!asyncOp.isDone) await TaskHelper.NextFrame();
+#endif
+            var loadedScene = SceneManager.GetSceneAt(SceneManager.loadedSceneCount - 1);
+            return new SceneHandle(loadedScene);
+        }
+
+        internal static async ValueTask UnloadSceneAsync(SceneHandle sceneHandle)
+        {
+#if UNITY_2023_2_OR_NEWER
+            await SceneManager.UnloadSceneAsync(sceneHandle.Scene);
+#else
+            var asyncOp = SceneManager.UnloadSceneAsync(sceneHandle.Scene);
+            while (!asyncOp.isDone) await TaskHelper.NextFrame();
+#endif
+        }
+    }
+}

Runtime/Assets/Scene/UnifiedSceneLoader.cs

@@ -2,7 +2,6 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Mew.Core.TaskHelpers;
-using UnityEngine;
 using UnityEngine.SceneManagement;
 
 #if USE_MEW_CORE_ASSETS
@@ -42,15 +41,7 @@ public static async Task<ISceneHandle> LoadAsync(UnifiedScene unifiedScene, Canc
 #endif
             if (unifiedScene.SceneReference is not null && unifiedScene.SceneReference.IsValid)
             {
-#if UNITY_2023_2_OR_NEWER
-                await SceneManager.LoadSceneAsync(unifiedScene.SceneReference, parameters);
-#else
-                var asyncOp = SceneManager.LoadSceneAsync(unifiedScene.SceneReference, parameters);
-                while (!asyncOp.isDone)
-                    await TaskHelper.NextFrame();
-#endif
-                var loadedScene = SceneManager.GetSceneAt(SceneManager.loadedSceneCount - 1);
-                handle = new SceneHandle(loadedScene);
+                handle = await CompatibleSceneLoader.LoadSceneAsync(unifiedScene, parameters);
             }
 #if UNITY_EDITOR
             // for test use
@@ -92,16 +83,7 @@ public static async ValueTask UnloadAsync(ISceneHandle targetHandle)
                 case SceneHandle sceneHandle:
                 {
                     if (sceneHandle.Scene.isLoaded)
-                    {
-#if UNITY_2023_2_OR_NEWER
-                        await SceneManager.UnloadSceneAsync(sceneHandle.Scene);
-#else
-                        var asyncOp = SceneManager.UnloadSceneAsync(sceneHandle.Scene);
-                        while (!asyncOp.isDone)
-                            await TaskHelper.NextFrame();
-#endif
-
-                    }
+                        await CompatibleSceneLoader.UnloadSceneAsync(sceneHandle);
                     break;
                 }
             }

Runtime/Helpers/Compatibility/TaskHelperInternal.cs

@@ -0,0 +1,45 @@
+#if UNITY_2023_2_OR_NEWER
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace Mew.Core.TaskHelpers
+{
+    internal static class TaskHelperInternal
+    {
+        private static readonly Stack<AwaitableCompletionSource> Pool = new();
+        private static readonly Queue<AwaitableCompletionSource> Queued = new();
+        private static readonly List<AwaitableCompletionSource> Running = new();
+        private static bool registered;
+
+        public static async Task NextFrame()
+        {
+            if (!registered)
+            {
+                MewLoop.Add<MewUnityUpdate>(OnUpdate);
+                registered = true;
+            }
+            if (Pool.Count == 0)
+                Pool.Push(new AwaitableCompletionSource());
+            var awaitableCompletionSource = Pool.Pop();
+            awaitableCompletionSource.Reset();
+            Queued.Enqueue(awaitableCompletionSource);
+            await awaitableCompletionSource.Awaitable;
+            return;
+
+            void OnUpdate()
+            {
+                while (Queued.Count > 0)
+                    Running.Add(Queued.Dequeue());
+
+                foreach (var completionSource in Running)
+                {
+                    completionSource.TrySetResult();
+                    Pool.Push(completionSource);
+                }
+                Running.Clear();
+            }
+        }
+    }
+}
+#endif

Runtime/Helpers/Compatibility/TaskHelperLegacyUnity.cs

@@ -0,0 +1,20 @@
+#if !UNITY_2023_2_OR_NEWER
+using System.Threading.Tasks;
+
+namespace Mew.Core.TaskHelpers
+{
+    internal static class TaskHelperLegacyInternal
+    {
+        public static async Task NextFrame()
+        {
+            TaskCompletionSource<bool> taskCompletionSource = new();
+            MewLoop.Add<MewUnityUpdate>(OnUpdate);
+            await taskCompletionSource.Task;
+            MewLoop.Remove<MewUnityUpdate>(OnUpdate);
+            return;
+
+            void OnUpdate() => taskCompletionSource.TrySetResult(true);
+        }
+    }
+}
+#endif

Runtime/Helpers/SceneManagerHelper.cs

@@ -1,4 +1,7 @@
 using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using UnityEngine;
 using UnityEngine.SceneManagement;
 
 namespace Mew.Core.SceneHelpers

Runtime/Helpers/TaskHelper.cs

@@ -1,54 +1,15 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using UnityEngine;
+using System.Threading.Tasks;
 
 namespace Mew.Core.TaskHelpers
 {
     public static class TaskHelper
     {
-#if UNITY_2023_2_OR_NEWER
-        private static readonly Stack<AwaitableCompletionSource> pool = new();
-        private static readonly Queue<AwaitableCompletionSource> queued = new();
-        private static readonly List<AwaitableCompletionSource> running = new();
-        private static bool registered;
-#endif
-
         public static async Task NextFrame()
         {
 #if UNITY_2023_2_OR_NEWER
-            if (!registered)
-            {
-                MewLoop.Add<MewUnityUpdate>(OnUpdate);
-                registered = true;
-            }
-            if (pool.Count == 0)
-                pool.Push(new AwaitableCompletionSource());
-            var awaitableCompletionSource = pool.Pop();
-            awaitableCompletionSource.Reset();
-            queued.Enqueue(awaitableCompletionSource);
-            await awaitableCompletionSource.Awaitable;
-            return;
-
-            void OnUpdate()
-            {
-                while (queued.Count > 0)
-                    running.Add(queued.Dequeue());
-
-                foreach (var completionSource in running)
-                {
-                    completionSource.TrySetResult();
-                    pool.Push(completionSource);
-                }
-                running.Clear();
-            }
+            await TaskHelperInternal.NextFrame();
 #else
-            TaskCompletionSource<bool> taskCompletionSource = new();
-            MewLoop.Add<MewUnityUpdate>(OnUpdate);
-            await taskCompletionSource.Task;
-            MewLoop.Remove<MewUnityUpdate>(OnUpdate);
-            return;
-
-            void OnUpdate() => taskCompletionSource.TrySetResult(true);
+            await TaskHelperLegacyInternal.NextFrame();
 #endif
         }
     }