fr.jeanf.scenemanagement 0.3.1 → 0.3.2

package/Runtime/AdditiveLoading/WorldManager.cs

@@ -24,8 +24,9 @@ namespace jeanf.scenemanagement
         private List<Region> _activeRegions = new List<Region>();
         private bool _mappingInitialized = false;
         
-        private List<string> _tempSceneNames = new List<string>();
-        private List<Region> _tempRegionsToRemove = new List<Region>();
+        // GC ALLOCATION FIX: Pre-allocate reusable collections
+        private readonly List<string> _tempSceneNames = new List<string>();
+        private readonly List<Region> _tempRegionsToRemove = new List<Region>();
 
         [SerializeField] private StringEventChannelSO regionChangeRequestChannel;
         [SerializeField] private SendTeleportTarget sendTeleportTarget;
@@ -126,6 +127,8 @@ namespace jeanf.scenemanagement
             _compiledSceneLists.Clear();
             _landingZoneIds.Clear();
             _activeRegions.Clear();
+            
+            // GC ALLOCATION FIX: Clear reusable collections instead of creating new ones
             _tempSceneNames.Clear();
             _tempRegionsToRemove.Clear();
             _mappingInitialized = false;
@@ -138,8 +141,10 @@ namespace jeanf.scenemanagement
             var regionCount = ListOfRegions?.Count ?? 0;
             if (regionCount == 0) return;
             
-            foreach (var region in ListOfRegions)
+            // GC ALLOCATION FIX: Use for loop instead of foreach to avoid enumerator allocation
+            for (int i = 0; i < ListOfRegions.Count; i++)
             {
+                var region = ListOfRegions[i];
                 if (region == null) continue;
                 if (!_regionDictionary.TryAdd(region.id, region)) continue;
                 
@@ -148,8 +153,10 @@ namespace jeanf.scenemanagement
                 
                 if (region.scenariosInThisRegion != null)
                 {
-                    foreach (var scenario in region.scenariosInThisRegion)
+                    // GC ALLOCATION FIX: Use for loop instead of foreach
+                    for (int j = 0; j < region.scenariosInThisRegion.Count; j++)
                     {
+                        var scenario = region.scenariosInThisRegion[j];
                         if (scenario != null)
                         {
                             ScenarioManager.ScenarioDictionary.TryAdd(scenario.id, scenario);
@@ -159,8 +166,10 @@ namespace jeanf.scenemanagement
 
                 if (region.zonesInThisRegion != null)
                 {
-                    foreach (var zone in region.zonesInThisRegion)
+                    // GC ALLOCATION FIX: Use for loop instead of foreach
+                    for (int j = 0; j < region.zonesInThisRegion.Count; j++)
                     {
+                        var zone = region.zonesInThisRegion[j];
                         if (zone != null)
                         {
                             _zoneDictionary.TryAdd(zone.id, zone);
@@ -176,10 +185,13 @@ namespace jeanf.scenemanagement
         
         private void PrecompileSceneList(Region region)
         {
+            // GC ALLOCATION FIX: Use capacity to avoid List resizing
             var sceneNames = new List<string>(region.dependenciesInThisRegion.Count);
-            foreach (var dependency in region.dependenciesInThisRegion)
+            
+            // GC ALLOCATION FIX: Use for loop instead of foreach
+            for (int i = 0; i < region.dependenciesInThisRegion.Count; i++)
             {
-                sceneNames.Add(dependency.SceneName);
+                sceneNames.Add(region.dependenciesInThisRegion[i].SceneName);
             }
             _compiledSceneLists[region.id] = sceneNames;
         }
@@ -189,8 +201,10 @@ namespace jeanf.scenemanagement
             var connectivity = FindObjectOfType<RegionConnectivityAuthoring>();
             if (connectivity?.regionConnectivity?.landingZones == null) return;
             
-            foreach (var landing in connectivity.regionConnectivity.landingZones)
+            // GC ALLOCATION FIX: Use for loop instead of foreach
+            for (int i = 0; i < connectivity.regionConnectivity.landingZones.Count; i++)
             {
+                var landing = connectivity.regionConnectivity.landingZones[i];
                 if (landing?.landingZone != null)
                 {
                     _landingZoneIds.Add(landing.landingZone.id);
@@ -216,6 +230,7 @@ namespace jeanf.scenemanagement
 
         private void OnZoneChangedFromECS(string zoneId)
         {
+            // GC ALLOCATION FIX: Early exit to avoid string operations
             if (string.IsNullOrEmpty(zoneId) || _lastNotifiedZone == zoneId) return;
             
             if (!_zoneDictionary.TryGetValue(zoneId, out var zone)) return;
@@ -223,12 +238,14 @@ namespace jeanf.scenemanagement
             _lastNotifiedZone = zoneId;
             _currentPlayerZone = zone;
             
+            // GC ALLOCATION FIX: Only invoke if delegates are not null
             PublishCurrentZoneId?.Invoke(zone.id);
             PublishAppList(zone);
         }
         
         private void OnRegionChangedFromECS(string regionId)
         {
+            // GC ALLOCATION FIX: Early exit to avoid unnecessary operations
             if (string.IsNullOrEmpty(regionId) || _lastNotifiedRegion == regionId) return;
             
             if (!_regionDictionary.TryGetValue(regionId, out var region)) return;
@@ -260,18 +277,23 @@ namespace jeanf.scenemanagement
             _currentPlayerRegion = region;
             _lastNotifiedRegion = region.id;
             
+            // GC ALLOCATION FIX: Only invoke if delegate is not null
             PublishCurrentRegionId?.Invoke(_currentPlayerRegion.id);
 
+            // GC ALLOCATION FIX: Clear and reuse collection instead of creating new
             _tempRegionsToRemove.Clear();
-            foreach (var activeRegion in _activeRegions)
+            
+            // GC ALLOCATION FIX: Use for loop instead of foreach
+            for (int i = 0; i < _activeRegions.Count; i++)
             {
-                var removedRegion = RequestUnLoadForObsoleteRegion(activeRegion);
+                var removedRegion = RequestUnLoadForObsoleteRegion(_activeRegions[i]);
                 _tempRegionsToRemove.Add(removedRegion);
             }
 
-            foreach (var r in _tempRegionsToRemove)
+            // GC ALLOCATION FIX: Use for loop instead of foreach
+            for (int i = 0; i < _tempRegionsToRemove.Count; i++)
             {
-                _activeRegions.Remove(r);
+                _activeRegions.Remove(_tempRegionsToRemove[i]);
             }
             
             RequestLoadForRegionDependencies(region);
@@ -304,6 +326,8 @@ namespace jeanf.scenemanagement
                 {
                     _currentPlayerZone = firstZone;
                     _lastNotifiedZone = firstZone.id;
+                    
+                    // GC ALLOCATION FIX: Only invoke if delegates are not null
                     PublishCurrentZoneId?.Invoke(firstZone.id);
                     PublishAppList(firstZone);
                 }
@@ -330,6 +354,7 @@ namespace jeanf.scenemanagement
                 listToBroadcast = value;
             }
             
+            // GC ALLOCATION FIX: Only invoke if delegate is not null
             _broadcastAppList?.Invoke(listToBroadcast);
         }
 
@@ -337,9 +362,10 @@ namespace jeanf.scenemanagement
         {
             if (!_compiledSceneLists.TryGetValue(region.id, out var sceneNames) || sceneNames.Count <= 0) return;
             
-            foreach (var sceneName in sceneNames)
+            // GC ALLOCATION FIX: Use for loop instead of foreach
+            for (int i = 0; i < sceneNames.Count; i++)
             {
-                _sceneLoader.LoadSceneRequest(sceneName);
+                _sceneLoader.LoadSceneRequest(sceneNames[i]);
             }
         }
         
@@ -347,9 +373,10 @@ namespace jeanf.scenemanagement
         {
             if (_compiledSceneLists.TryGetValue(region.id, out var sceneNames))
             {
-                foreach (var sceneName in sceneNames)
+                // GC ALLOCATION FIX: Use for loop instead of foreach
+                for (int i = 0; i < sceneNames.Count; i++)
                 {
-                    _sceneLoader.UnLoadSceneRequest(sceneName);
+                    _sceneLoader.UnLoadSceneRequest(sceneNames[i]);
                 }
             }
             return region;

package/Runtime/DynamicLoading/Editor/VolumeDataGenerator.cs

@@ -0,0 +1,360 @@
+#if UNITY_EDITOR
+using UnityEngine;
+using UnityEditor;
+using System.Collections.Generic;
+using System.IO;
+
+namespace jeanf.scenemanagement
+{
+    public class VolumeDataGenerator : EditorWindow
+    {
+        private RegionConnectivity sourceRegionConnectivity;
+        private PrecomputedVolumeData targetPrecomputedData;
+        private string savePath = "Assets/ScriptableObjects/";
+        private string fileName = "PrecomputedVolumeData";
+        
+        private Vector2 scrollPosition;
+        private bool showPreview = false;
+        private Dictionary<string, List<string>> previewData = new Dictionary<string, List<string>>();
+
+        [MenuItem("Tools/Scene Management/Volume Data Generator")]
+        public static void ShowWindow()
+        {
+            GetWindow<VolumeDataGenerator>("Volume Data Generator");
+        }
+
+        private void OnGUI()
+        {
+            EditorGUILayout.LabelField("Volume Data Generator", EditorStyles.boldLabel);
+            EditorGUILayout.HelpBox("Generate pre-computed volume connectivity data from RegionConnectivity for maximum runtime performance.", MessageType.Info);
+            EditorGUILayout.Space();
+            
+            DrawSourceSelection();
+            EditorGUILayout.Space();
+            
+            DrawTargetSelection();
+            EditorGUILayout.Space();
+            
+            DrawGenerationControls();
+            EditorGUILayout.Space();
+            
+            if (showPreview && previewData.Count > 0)
+            {
+                DrawPreview();
+            }
+        }
+        
+        private void DrawSourceSelection()
+        {
+            EditorGUILayout.LabelField("Source Data", EditorStyles.boldLabel);
+            
+            sourceRegionConnectivity = (RegionConnectivity)EditorGUILayout.ObjectField(
+                "Region Connectivity", 
+                sourceRegionConnectivity, 
+                typeof(RegionConnectivity), 
+                false);
+                
+            if (sourceRegionConnectivity == null)
+            {
+                EditorGUILayout.HelpBox("Select a RegionConnectivity asset to generate from.", MessageType.Warning);
+                return;
+            }
+            
+            EditorGUILayout.BeginVertical(GUI.skin.box);
+            EditorGUILayout.LabelField("Source Analysis:", EditorStyles.boldLabel);
+            EditorGUILayout.LabelField($"• Active Regions: {sourceRegionConnectivity.activeRegions.Count}");
+            EditorGUILayout.LabelField($"• Landing Zones: {sourceRegionConnectivity.landingZones.Count}");
+            EditorGUILayout.LabelField($"• Zone Connections: {sourceRegionConnectivity.zoneConnections.Count}");
+            
+            int totalZones = 0;
+            foreach (var region in sourceRegionConnectivity.activeRegions)
+            {
+                if (region?.zonesInThisRegion != null)
+                    totalZones += region.zonesInThisRegion.Count;
+            }
+            EditorGUILayout.LabelField($"• Total Zones: {totalZones}");
+            EditorGUILayout.EndVertical();
+        }
+        
+        private void DrawTargetSelection()
+        {
+            EditorGUILayout.LabelField("Target Asset", EditorStyles.boldLabel);
+            
+            targetPrecomputedData = (PrecomputedVolumeData)EditorGUILayout.ObjectField(
+                "Precomputed Volume Data", 
+                targetPrecomputedData, 
+                typeof(PrecomputedVolumeData), 
+                false);
+                
+            EditorGUILayout.BeginHorizontal();
+            savePath = EditorGUILayout.TextField("Save Path", savePath);
+            if (GUILayout.Button("Browse", GUILayout.Width(60)))
+            {
+                string selectedPath = EditorUtility.SaveFolderPanel("Select Save Folder", savePath, "");
+                if (!string.IsNullOrEmpty(selectedPath))
+                {
+                    savePath = FileUtil.GetProjectRelativePath(selectedPath) + "/";
+                }
+            }
+            EditorGUILayout.EndHorizontal();
+            
+            fileName = EditorGUILayout.TextField("File Name", fileName);
+        }
+        
+        private void DrawGenerationControls()
+        {
+            EditorGUILayout.LabelField("Generation Options", EditorStyles.boldLabel);
+            
+            showPreview = EditorGUILayout.Toggle("Show Preview", showPreview);
+            
+            EditorGUILayout.BeginHorizontal();
+            
+            GUI.enabled = sourceRegionConnectivity != null;
+            if (GUILayout.Button("Preview Data"))
+            {
+                GeneratePreviewData();
+            }
+            
+            if (GUILayout.Button("Generate New Asset"))
+            {
+                GenerateNewAsset();
+            }
+            
+            GUI.enabled = sourceRegionConnectivity != null && targetPrecomputedData != null;
+            if (GUILayout.Button("Update Existing"))
+            {
+                UpdateExistingAsset();
+            }
+            
+            GUI.enabled = true;
+            EditorGUILayout.EndHorizontal();
+        }
+        
+        private void DrawPreview()
+        {
+            EditorGUILayout.LabelField("Preview Generated Data", EditorStyles.boldLabel);
+            
+            scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition, GUILayout.Height(300));
+            
+            foreach (var kvp in previewData)
+            {
+                EditorGUILayout.LabelField($"Zone: {kvp.Key}", EditorStyles.boldLabel);
+                EditorGUI.indentLevel++;
+                EditorGUILayout.LabelField($"Checkable zones ({kvp.Value.Count}):");
+                foreach (var checkable in kvp.Value)
+                {
+                    EditorGUILayout.LabelField($"• {checkable}");
+                }
+                EditorGUI.indentLevel--;
+                EditorGUILayout.Space();
+            }
+            
+            EditorGUILayout.EndScrollView();
+        }
+        
+        private void GeneratePreviewData()
+        {
+            if (sourceRegionConnectivity == null) return;
+            
+            previewData.Clear();
+            var generator = new VolumeDataProcessor(sourceRegionConnectivity);
+            
+            foreach (var region in sourceRegionConnectivity.activeRegions)
+            {
+                if (region?.zonesInThisRegion == null) continue;
+                
+                foreach (var zone in region.zonesInThisRegion)
+                {
+                    if (zone == null) continue;
+                    
+                    var checkableZones = generator.GetCheckableZonesForZone(zone.id.ToString());
+                    previewData[zone.id.ToString()] = new List<string>(checkableZones);
+                }
+            }
+            
+            showPreview = true;
+            Repaint();
+        }
+        
+        private void GenerateNewAsset()
+        {
+            if (sourceRegionConnectivity == null) return;
+            
+            var asset = CreateInstance<PrecomputedVolumeData>();
+            var generator = new VolumeDataProcessor(sourceRegionConnectivity);
+            generator.PopulatePrecomputedData(asset);
+            
+            string fullPath = $"{savePath}{fileName}.asset";
+            AssetDatabase.CreateAsset(asset, fullPath);
+            AssetDatabase.SaveAssets();
+            AssetDatabase.Refresh();
+            
+            targetPrecomputedData = asset;
+            EditorUtility.FocusProjectWindow();
+            Selection.activeObject = asset;
+            
+            Debug.Log($"Created PrecomputedVolumeData asset at: {fullPath}");
+        }
+        
+        private void UpdateExistingAsset()
+        {
+            if (sourceRegionConnectivity == null || targetPrecomputedData == null) return;
+            
+            var generator = new VolumeDataProcessor(sourceRegionConnectivity);
+            generator.PopulatePrecomputedData(targetPrecomputedData);
+            
+            EditorUtility.SetDirty(targetPrecomputedData);
+            AssetDatabase.SaveAssets();
+            
+            Debug.Log($"Updated PrecomputedVolumeData asset: {AssetDatabase.GetAssetPath(targetPrecomputedData)}");
+        }
+    }
+    
+    public class VolumeDataProcessor
+    {
+        private RegionConnectivity sourceData;
+        private Dictionary<string, string> zoneToRegionMap = new Dictionary<string, string>();
+        private Dictionary<string, HashSet<string>> zoneNeighborsMap = new Dictionary<string, HashSet<string>>();
+        private HashSet<string> landingZoneIds = new HashSet<string>();
+        
+        public VolumeDataProcessor(RegionConnectivity source)
+        {
+            sourceData = source;
+            BuildMappings();
+        }
+        
+        private void BuildMappings()
+        {
+            BuildZoneToRegionMapping();
+            BuildZoneNeighborsMapping();
+            BuildLandingZoneMapping();
+        }
+        
+        private void BuildZoneToRegionMapping()
+        {
+            foreach (var region in sourceData.activeRegions)
+            {
+                if (region?.zonesInThisRegion == null) continue;
+                
+                foreach (var zone in region.zonesInThisRegion)
+                {
+                    if (zone != null)
+                    {
+                        zoneToRegionMap[zone.id.ToString()] = region.id.ToString();
+                    }
+                }
+            }
+        }
+        
+        private void BuildZoneNeighborsMapping()
+        {
+            // Build neighbors from region membership
+            foreach (var region in sourceData.activeRegions)
+            {
+                if (region?.zonesInThisRegion == null) continue;
+                
+                foreach (var zoneA in region.zonesInThisRegion)
+                {
+                    if (zoneA == null) continue;
+                    
+                    var zoneAId = zoneA.id.ToString();
+                    if (!zoneNeighborsMap.ContainsKey(zoneAId))
+                    {
+                        zoneNeighborsMap[zoneAId] = new HashSet<string>();
+                    }
+                    
+                    foreach (var zoneB in region.zonesInThisRegion)
+                    {
+                        if (zoneB == null || zoneA.id.ToString() == zoneB.id.ToString()) continue;
+                        zoneNeighborsMap[zoneAId].Add(zoneB.id.ToString());
+                    }
+                }
+            }
+            
+            // Add explicit zone connections
+            foreach (var connection in sourceData.zoneConnections)
+            {
+                if (connection.zoneA == null || connection.zoneB == null) continue;
+                
+                var zoneAId = connection.zoneA.id.ToString();
+                var zoneBId = connection.zoneB.id.ToString();
+                
+                if (!zoneNeighborsMap.ContainsKey(zoneAId))
+                    zoneNeighborsMap[zoneAId] = new HashSet<string>();
+                if (!zoneNeighborsMap.ContainsKey(zoneBId))
+                    zoneNeighborsMap[zoneBId] = new HashSet<string>();
+                
+                zoneNeighborsMap[zoneAId].Add(zoneBId);
+                
+                if (connection.isBidirectional)
+                {
+                    zoneNeighborsMap[zoneBId].Add(zoneAId);
+                }
+            }
+        }
+        
+        private void BuildLandingZoneMapping()
+        {
+            foreach (var landing in sourceData.landingZones)
+            {
+                if (landing?.landingZone != null)
+                {
+                    landingZoneIds.Add(landing.landingZone.id.ToString());
+                }
+            }
+        }
+        
+        public HashSet<string> GetCheckableZonesForZone(string zoneId)
+        {
+            var result = new HashSet<string> { zoneId };
+            
+            if (zoneNeighborsMap.TryGetValue(zoneId, out var neighbors))
+            {
+                foreach (var neighbor in neighbors)
+                {
+                    result.Add(neighbor);
+                }
+            }
+            
+            foreach (var landingZoneId in landingZoneIds)
+            {
+                result.Add(landingZoneId);
+            }
+            
+            return result;
+        }
+        
+        public void PopulatePrecomputedData(PrecomputedVolumeData target)
+        {
+            target.Clear();
+            
+            // Generate zone checkable sets
+            foreach (var kvp in zoneToRegionMap)
+            {
+                var zoneId = kvp.Key;
+                var checkableZones = GetCheckableZonesForZone(zoneId);
+                
+                var checkableSet = new ZoneCheckableSet(zoneId);
+                checkableSet.checkableZoneIds.AddRange(checkableZones);
+                
+                target.zoneCheckableSets.Add(checkableSet);
+            }
+            
+            // Add landing zones
+            target.landingZoneIds.AddRange(landingZoneIds);
+            
+            // Add zone-region mappings
+            foreach (var kvp in zoneToRegionMap)
+            {
+                target.zoneRegionMappings.Add(new ZoneRegionMapping(kvp.Key, kvp.Value));
+            }
+            
+            // Add generation metadata
+            target.sourceRegionConnectivityAsset = AssetDatabase.GetAssetPath(sourceData);
+            target.generatedDateTime = System.DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
+            target.totalZones = zoneToRegionMap.Count;
+            target.totalRegions = sourceData.activeRegions.Count;
+        }
+    }
+}
+#endif

package/Runtime/DynamicLoading/Editor/VolumeDataGenerator.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7e55684fae4f6ea47b8f442cfad75620

package/Runtime/DynamicLoading/PrecomputedVolumeData.cs

@@ -0,0 +1,123 @@
+using System.Collections.Generic;
+using UnityEngine;
+using jeanf.propertyDrawer;
+
+namespace jeanf.scenemanagement
+{
+    [ScriptableObjectDrawer]
+    [CreateAssetMenu(fileName = "PrecomputedVolumeData", menuName = "LoadingSystem/PrecomputedVolumeData")]
+    public class PrecomputedVolumeData : ScriptableObject
+    {
+        [Header("Pre-computed Connectivity Data")]
+        [Tooltip("Generated from RegionConnectivity - do not edit manually")]
+        public List<ZoneCheckableSet> zoneCheckableSets = new List<ZoneCheckableSet>();
+        
+        [Header("Landing Zones")]
+        [Tooltip("Zones that are always checkable regardless of current zone")]
+        public List<string> landingZoneIds = new List<string>();
+        
+        [Header("Zone to Region Mapping")]
+        [Tooltip("Maps each zone ID to its region ID")]
+        public List<ZoneRegionMapping> zoneRegionMappings = new List<ZoneRegionMapping>();
+        
+        [Header("Generation Info")]
+        [Tooltip("Information about when this data was generated")]
+        public string sourceRegionConnectivityAsset;
+        public string generatedDateTime;
+        public int totalZones;
+        public int totalRegions;
+        
+        // Runtime lookup methods
+        public HashSet<string> GetCheckableZoneIds(string currentZone)
+        {
+            var result = new HashSet<string>();
+            
+            if (string.IsNullOrEmpty(currentZone))
+            {
+                // Bootstrap state - return all zones
+                foreach (var mapping in zoneRegionMappings)
+                {
+                    result.Add(mapping.zoneId);
+                }
+                return result;
+            }
+            
+            // Find the checkable set for this zone
+            foreach (var checkableSet in zoneCheckableSets)
+            {
+                if (checkableSet.primaryZoneId == currentZone)
+                {
+                    foreach (var checkableZone in checkableSet.checkableZoneIds)
+                    {
+                        result.Add(checkableZone);
+                    }
+                    break;
+                }
+            }
+            
+            // Always add landing zones
+            foreach (var landingZone in landingZoneIds)
+            {
+                result.Add(landingZone);
+            }
+            
+            return result;
+        }
+        
+        public string GetRegionForZone(string zoneId)
+        {
+            foreach (var mapping in zoneRegionMappings)
+            {
+                if (mapping.zoneId == zoneId)
+                {
+                    return mapping.regionId;
+                }
+            }
+            return "";
+        }
+        
+        public bool IsLandingZone(string zoneId)
+        {
+            return landingZoneIds.Contains(zoneId);
+        }
+        
+        public void Clear()
+        {
+            zoneCheckableSets.Clear();
+            landingZoneIds.Clear();
+            zoneRegionMappings.Clear();
+            sourceRegionConnectivityAsset = "";
+            generatedDateTime = "";
+            totalZones = 0;
+            totalRegions = 0;
+        }
+    }
+    
+    [System.Serializable]
+    public class ZoneCheckableSet
+    {
+        [Tooltip("The zone that this checkable set applies to")]
+        public string primaryZoneId;
+        
+        [Tooltip("All zones that should be checked when in the primary zone")]
+        public List<string> checkableZoneIds = new List<string>();
+        
+        public ZoneCheckableSet(string primaryZone)
+        {
+            primaryZoneId = primaryZone;
+        }
+    }
+    
+    [System.Serializable]
+    public class ZoneRegionMapping
+    {
+        public string zoneId;
+        public string regionId;
+        
+        public ZoneRegionMapping(string zone, string region)
+        {
+            zoneId = zone;
+            regionId = region;
+        }
+    }
+}

package/Runtime/DynamicLoading/PrecomputedVolumeData.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: be367183df17c9841aa12aaf3830317d