Merge pull request #55 from arimger/bugfix/fix-serialized-scene-serialization

Bugfix/fix serialized scene serialization

Author: arimger

Assets/Editor Toolbox/Editor/Drawers/Regular/SerializedSceneDrawer.cs

@@ -103,16 +103,24 @@ public static SceneData GetSceneData(SerializedProperty property)
                 var sceneAsset = property.objectReferenceValue as SceneAsset;
                 var scenePath = AssetDatabase.GetAssetPath(sceneAsset);
                 var sceneGuid = AssetDatabase.AssetPathToGUID(scenePath);
+                var sceneIndex = -1;
                 for (var i = 0; i < EditorBuildSettings.scenes.Length; i++)
                 {
                     var sceneSettings = EditorBuildSettings.scenes[i];
+                    var isEnabled = sceneSettings.enabled;
+                    if (isEnabled)
+                    {
+                        sceneIndex++;
+                    }
+
                     var guid = sceneSettings.guid;
                     if (guid.Equals(new GUID(sceneGuid)))
                     {
-                        sceneData.index = i;
-                        sceneData.enabled = sceneSettings.enabled;
+                        sceneData.index = isEnabled ? sceneIndex : -1;
+                        sceneData.enabled = isEnabled;
                         sceneData.guid = guid;
                         sceneData.inBuild = true;
+                        break;
                     }
                 }
 

Assets/Editor Toolbox/Runtime/Serialization/SceneData.cs

@@ -0,0 +1,9 @@
+namespace Toolbox.Serialization
+{
+    internal class SceneData
+    {
+        public string SceneName { get; set; }
+        public string ScenePath { get; set; }
+        public int BuildIndex { get; set; }
+    }
+}

Assets/Editor Toolbox/Runtime/Serialization/SceneData.cs.meta

@@ -0,0 +1,78 @@
+using System.Collections.Generic;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace Toolbox.Serialization
+{
+    internal static class SceneSerializationUtility
+    {
+#if UNITY_EDITOR
+        private static readonly Dictionary<SceneAsset, SceneData> cachedScenes = new Dictionary<SceneAsset, SceneData>();
+        private static bool isInitialized;
+
+
+        [InitializeOnLoadMethod]
+        private static void Initialize()
+        {
+            if (isInitialized)
+            {
+                return;
+            }
+
+            ConfirmCache();
+            EditorBuildSettings.sceneListChanged -= RefreshCache;
+            EditorBuildSettings.sceneListChanged += RefreshCache;
+            isInitialized = true;
+        }
+
+        private static void ConfirmCache()
+        {
+            //NOTE: refresh data only if the cache is empty,
+            //it probably means that it's our first time when we are updating it
+            if (cachedScenes.Count == 0)
+            {
+                RefreshCache();
+            }
+        }
+
+        private static void RefreshCache()
+        {
+            cachedScenes.Clear();
+            var buildIndex = -1;
+            foreach (var scene in EditorBuildSettings.scenes)
+            {
+                if (!scene.enabled)
+                {
+                    continue;
+                }
+
+                buildIndex++;
+                var sceneAsset = EditorGUIUtility.Load(scene.path) as SceneAsset;
+                if (sceneAsset != null)
+                {
+                    cachedScenes.Add(sceneAsset, new SceneData()
+                    {
+                        BuildIndex = buildIndex,
+                        SceneName = sceneAsset.name,
+                        ScenePath = scene.path
+                    });
+                }
+            }
+        }
+
+
+        public static bool TryGetSceneData(SceneAsset sceneAsset, out SceneData data)
+        {
+            ConfirmCache();
+            if (!sceneAsset || !cachedScenes.TryGetValue(sceneAsset, out data))
+            {
+                data = null;
+                return false;
+            }
+
+            return true;
+        }
+#endif
+    }
+}

Assets/Editor Toolbox/Runtime/Serialization/SceneSerializationUtility.cs

@@ -1,5 +1,7 @@
 using System;
-using System.Collections.Generic;
+
+using Toolbox.Serialization;
+
 #if UNITY_EDITOR
 using UnityEditor;
 #endif
@@ -13,8 +15,6 @@ namespace UnityEngine
     public class SerializedScene : ISerializationCallbackReceiver
     {
 #if UNITY_EDITOR
-        private readonly static Dictionary<SceneAsset, int> cachedBuildIndexes = new Dictionary<SceneAsset, int>();
-
         [SerializeField]
         private SceneAsset sceneReference;
 #endif
@@ -26,87 +26,34 @@ public class SerializedScene : ISerializationCallbackReceiver
         private int buildIndex;
 
 
-        void ISerializationCallbackReceiver.OnAfterDeserialize()
-        { }
-
         void ISerializationCallbackReceiver.OnBeforeSerialize()
         {
-#if UNITY_EDITOR
-            TryGetBuildIndex(sceneReference, out buildIndex);
-            TryGetSceneName(sceneReference, out sceneName);
-            TryGetScenePath(sceneReference, out scenePath);
-#endif
+            UpdateProperties();
         }
 
-        //TODO:
-        // 1 - move it to other class
-        // 2 - try cache indexes in runtime but only if needed
-        // 3 - update indexes before build
-#if UNITY_EDITOR
-        [InitializeOnLoadMethod, RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
-        private static void Initialize()
-        {
-            UpdateAllIndexes();
-
-            EditorBuildSettings.sceneListChanged -= UpdateAllIndexes;
-            EditorBuildSettings.sceneListChanged += UpdateAllIndexes;
-        }
-
-        private static void UpdateAllIndexes()
-        {
-            cachedBuildIndexes.Clear();
-
-            var buildIndex = -1;
-            foreach (var scene in EditorBuildSettings.scenes)
-            {
-                if (scene.enabled)
-                {
-                    buildIndex++;
-                    var sceneAsset = AssetDatabase.LoadAssetAtPath<SceneAsset>(scene.path);
-                    if (sceneAsset != null)
-                    {
-                        cachedBuildIndexes.Add(sceneAsset, buildIndex);
-                    }
-                }
-            }
-        }
-
-        private static bool TryGetBuildIndex(SceneAsset sceneAsset, out int index)
-        {
-            if (sceneAsset == null || !cachedBuildIndexes.TryGetValue(sceneAsset, out index))
-            {
-                index = -1;
-                return false;
-            }
+        void ISerializationCallbackReceiver.OnAfterDeserialize()
+        { }
 
-            return true;
-        }
 
-        private static bool TryGetSceneName(SceneAsset sceneAsset, out string name)
+        private void UpdateProperties()
         {
-            if (sceneAsset == null)
+#if UNITY_EDITOR       
+            if (SceneSerializationUtility.TryGetSceneData(sceneReference, out var sceneData))
             {
-                name = null;
-                return false;
+                SceneName = sceneData.SceneName;
+                ScenePath = sceneData.ScenePath;
+                BuildIndex = sceneData.BuildIndex;
             }
-
-            name = sceneAsset.name;
-            return true;
-        }
-
-        public static bool TryGetScenePath(SceneAsset sceneAsset, out string path)
-        {
-            if (sceneAsset == null)
+            else
             {
-                path = null;
-                return false;
+                SceneName = string.Empty;
+                ScenePath = string.Empty;
+                BuildIndex = -1;
             }
-
-            path = AssetDatabase.GetAssetPath(sceneAsset);
-            return true;
+#endif
         }
 
-
+#if UNITY_EDITOR
         public SceneAsset SceneReference
         {
             get => sceneReference;