fr.jeanf.scenemanagement 0.1.2 → 0.2.0

package/Runtime/AdditiveLoading/Editor/SpawnPosEditor.cs

@@ -0,0 +1,55 @@
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEngine;
+
+namespace jeanf.scenemanagement
+{
+    [CustomEditor(typeof(WorldManager))]
+    public class SpawnPosEditor : Editor
+    {
+        private void OnSceneGUI()
+        {
+            WorldManager worldManager = (WorldManager) target;
+            if (worldManager.ListOfRegions == null) return;
+
+            foreach (var region in worldManager.ListOfRegions)
+            {
+                if (region.isUsingOnInitSpawnPos)
+                {
+                    DrawSpawnPosHandle(ref region.SpawnPosOnInit, $"{region.levelName} - Initial Spawn");
+                }
+                DrawSpawnPosHandle(ref region.SpawnPosOnRegionChangeRequest, $"{region.levelName} - Manual Spawn");
+            }
+        }
+
+        private void DrawSpawnPosHandle(ref SpawnPos spawnPos, string label)
+        {
+            EditorGUI.BeginChangeCheck();
+
+            float handleSize = HandleUtility.GetHandleSize(spawnPos.position) * .5f;
+        
+            // Draw position handle
+            Vector3 newPosition = Handles.PositionHandle(spawnPos.position, Quaternion.identity);
+        
+            // Draw rotation handle (only yaw rotation around Y-axis)
+            Quaternion newRotation = Handles.Disc(Quaternion.Euler(spawnPos.rotation), spawnPos.position, Vector3.up, handleSize, false, 1f);
+        
+            // Draw label
+            Handles.Label(spawnPos.position, label, new GUIStyle { fontStyle = FontStyle.Bold, normal = new GUIStyleState { textColor = Color.white } });
+        
+            // Draw front marker with scaled size
+            Vector3 forward = Quaternion.Euler(spawnPos.rotation) * Vector3.forward * handleSize;
+            Handles.color = Color.cyan;
+            Handles.ArrowHandleCap(0, spawnPos.position, Quaternion.LookRotation(forward), handleSize, EventType.Repaint);
+        
+            if (EditorGUI.EndChangeCheck())
+            {
+                Undo.RecordObject(Selection.activeGameObject, "Move Spawn Position");
+                spawnPos.position = newPosition;
+                spawnPos.rotation = new Vector3(0, newRotation.eulerAngles.y, 0);
+                EditorUtility.SetDirty(Selection.activeGameObject);
+            }
+        }
+    }
+}
+#endif

package/Runtime/AdditiveLoading/Editor/SpawnPosEditor.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 57c3746d33c54dd488374a9b9d3eb9b4
+timeCreated: 1748312663

package/Runtime/AdditiveLoading/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1568e5d4a5f1a3e4dbb8adfe07d84b47
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/AdditiveLoading/Region.cs

@@ -48,54 +48,5 @@ namespace jeanf.scenemanagement
         }
     }
     
-    
-    #if UNITY_EDITOR
-    [CustomEditor(typeof(WorldManager))]
-    public class SpawnPosEditor : Editor
-    {
-        private void OnSceneGUI()
-        {
-            WorldManager worldManager = (WorldManager)target;
-            if (worldManager.ListOfRegions == null) return;
-
-            foreach (var region in worldManager.ListOfRegions)
-            {
-                if (region.isUsingOnInitSpawnPos)
-                {
-                    DrawSpawnPosHandle(ref region.SpawnPosOnInit, $"{region.levelName} - Initial Spawn");
-                }
-                DrawSpawnPosHandle(ref region.SpawnPosOnRegionChangeRequest, $"{region.levelName} - Manual Spawn");
-            }
-        }
-
-        private void DrawSpawnPosHandle(ref SpawnPos spawnPos, string label)
-        {
-            EditorGUI.BeginChangeCheck();
-
-            float handleSize = HandleUtility.GetHandleSize(spawnPos.position) * .5f;
-        
-            // Draw position handle
-            Vector3 newPosition = Handles.PositionHandle(spawnPos.position, Quaternion.identity);
-        
-            // Draw rotation handle (only yaw rotation around Y-axis)
-            Quaternion newRotation = Handles.Disc(Quaternion.Euler(spawnPos.rotation), spawnPos.position, Vector3.up, handleSize, false, 1f);
-        
-            // Draw label
-            Handles.Label(spawnPos.position, label, new GUIStyle { fontStyle = FontStyle.Bold, normal = new GUIStyleState { textColor = Color.white } });
-        
-            // Draw front marker with scaled size
-            Vector3 forward = Quaternion.Euler(spawnPos.rotation) * Vector3.forward * handleSize;
-            Handles.color = Color.cyan;
-            Handles.ArrowHandleCap(0, spawnPos.position, Quaternion.LookRotation(forward), handleSize, EventType.Repaint);
-        
-            if (EditorGUI.EndChangeCheck())
-            {
-                Undo.RecordObject(Selection.activeGameObject, "Move Spawn Position");
-                spawnPos.position = newPosition;
-                spawnPos.rotation = new Vector3(0, newRotation.eulerAngles.y, 0);
-                EditorUtility.SetDirty(Selection.activeGameObject);
-            }
-        }
-    }
-    #endif
+ 
 }

package/Runtime/AdditiveLoading/SceneLoader.cs

@@ -13,6 +13,7 @@ namespace jeanf.scenemanagement
         public bool isDebug = false;
         private CancellationTokenSource _queueCts;
         [SerializeField] private int maxConcurrentLoads = 2; 
+        
         public delegate void IsLoadingDelegate(bool loadingState);
         public static IsLoadingDelegate IsLoading;
         
@@ -20,22 +21,32 @@ namespace jeanf.scenemanagement
         public LoadScene LoadSceneRequest;
         public LoadScene UnLoadSceneRequest;
     
-    public delegate void UnloadAllScenesDelegate();
-    public UnloadAllScenesDelegate UnloadAllScenesRequest;
+        public delegate void UnloadAllScenesDelegate();
+        public UnloadAllScenesDelegate UnloadAllScenesRequest;
         
         public delegate void FlushScenesDelegate();
         public FlushScenesDelegate FlushScenesRequest;
         
-        private record SceneOperation(SceneOperationType Type, string SceneName)
+        private readonly struct SceneOperation
         {
-            public SceneOperationType Type { get; } = Type;
-            public string SceneName { get; } = SceneName;
+            public readonly SceneOperationType Type;
+            public readonly string SceneName;
+            
+            public SceneOperation(SceneOperationType type, string sceneName)
+            {
+                Type = type;
+                SceneName = sceneName;
+            }
         }
 
         private readonly ConcurrentQueue<SceneOperation> _loadQueue = new();
         private readonly ConcurrentQueue<SceneOperation> _unloadQueue = new();
         private readonly HashSet<string> _loadedScenes = new();
         private readonly HashSet<string> _processingScenes = new();
+        
+        private readonly List<UniTask> _operationBuffer = new();
+        private readonly List<string> _scenesToUnload = new();
+        
         private bool _isProcessingLoadQueue = false;
         private bool _isProcessingUnloadQueue = false;
 
@@ -75,11 +86,17 @@ namespace jeanf.scenemanagement
         {
             if (isDebug) Debug.Log("Unloading all scenes");
             
-            _loadQueue.Clear();
+            while (_loadQueue.TryDequeue(out _)) { }
             
-            foreach (var sceneName in new HashSet<string>(_loadedScenes))
+            _scenesToUnload.Clear();
+            foreach (var sceneName in _loadedScenes)
             {
-                _unloadQueue.Enqueue(new SceneOperation(SceneOperationType.Unload, sceneName));
+                _scenesToUnload.Add(sceneName);
+            }
+            
+            for (int i = 0; i < _scenesToUnload.Count; i++)
+            {
+                _unloadQueue.Enqueue(new SceneOperation(SceneOperationType.Unload, _scenesToUnload[i]));
             }
             
             ProcessUnloadQueue().Forget();
@@ -89,7 +106,6 @@ namespace jeanf.scenemanagement
         {
             if (isDebug) Debug.Log("Flushing memory");
             
-            // Force garbage collection to reclaim memory
             await Resources.UnloadUnusedAssets().ToUniTask(cancellationToken: cancellationToken);
             GC.Collect();
             
@@ -113,25 +129,22 @@ namespace jeanf.scenemanagement
             {
                 while (_loadQueue.Count > 0 && !token.IsCancellationRequested)
                 {
-                    var operations = new List<UniTask>();
+                    _operationBuffer.Clear();
                     
-                    while (operations.Count < maxConcurrentLoads && _loadQueue.TryDequeue(out var operation))
+                    while (_operationBuffer.Count < maxConcurrentLoads && _loadQueue.TryDequeue(out var operation))
                     {
                         if (_processingScenes.Contains(operation.SceneName) || _loadedScenes.Contains(operation.SceneName))
                             continue;
                             
                         _processingScenes.Add(operation.SceneName);
-                        
-                        if (isDebug) Debug.Log($"Loading scene: {operation.SceneName}");
-                        operations.Add(LoadSceneAsync(operation.SceneName, token));
+                        _operationBuffer.Add(LoadSceneAsync(operation.SceneName, token));
                     }
 
-                    if (operations.Count > 0)
+                    if (_operationBuffer.Count > 0)
                     {
-                        await UniTask.WhenAll(operations);
+                        await UniTask.WhenAll(_operationBuffer);
                     }
                     
-                    // Small delay to prevent overwhelming the system
                     await UniTask.Yield();
                 }
             }
@@ -162,22 +175,20 @@ namespace jeanf.scenemanagement
             {
                 while (_unloadQueue.Count > 0 && !token.IsCancellationRequested)
                 {
-                    var operations = new List<UniTask>();
+                    _operationBuffer.Clear();
                     
-                    while (operations.Count < maxConcurrentLoads && _unloadQueue.TryDequeue(out var operation))
+                    while (_operationBuffer.Count < maxConcurrentLoads && _unloadQueue.TryDequeue(out var operation))
                     {
                         if (!_loadedScenes.Contains(operation.SceneName) || _processingScenes.Contains(operation.SceneName))
                             continue;
                             
                         _processingScenes.Add(operation.SceneName);
-                        
-                        if (isDebug) Debug.Log($"Unloading scene: {operation.SceneName}");
-                        operations.Add(UnloadSceneAsync(operation.SceneName, token));
+                        _operationBuffer.Add(UnloadSceneAsync(operation.SceneName, token));
                     }
 
-                    if (operations.Count > 0)
+                    if (_operationBuffer.Count > 0)
                     {
-                        await UniTask.WhenAll(operations);
+                        await UniTask.WhenAll(_operationBuffer);
                     }
                     
                     // Small delay to prevent overwhelming the system
@@ -201,17 +212,14 @@ namespace jeanf.scenemanagement
 
         private async UniTask LoadSceneAsync(string sceneName, CancellationToken cancellationToken)
         {
+            AsyncOperation loadOperation = null;
+    
             try
             {
-                var loadOperation = SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Additive);
-                loadOperation!.allowSceneActivation = true;
+                loadOperation = SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Additive);
+                loadOperation.allowSceneActivation = true;
                 await loadOperation.ToUniTask(cancellationToken: cancellationToken);
                 _loadedScenes.Add(sceneName);
-                if (isDebug) Debug.Log($"Scene loaded: {sceneName}");
-            }
-            catch (Exception e)
-            {
-                if (isDebug) Debug.LogError($"Error loading scene {sceneName}: {e}");
             }
             finally
             {
@@ -226,11 +234,6 @@ namespace jeanf.scenemanagement
                 var unloadOperation = SceneManager.UnloadSceneAsync(sceneName);
                 await unloadOperation.ToUniTask(cancellationToken: cancellationToken);
                 _loadedScenes.Remove(sceneName);
-                if (isDebug) Debug.Log($"Scene unloaded: {sceneName}");
-            }
-            catch (Exception e)
-            {
-                if (isDebug) Debug.LogError($"Error unloading scene {sceneName}: {e}");
             }
             finally
             {