added unity files

Assets/RL_DevPlus1/Editor/ProjectAnalyzer/RLSceneAnalyzer.cs

@@ -0,0 +1,193 @@
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace RunlevelSystems.DevPlus1.EditorTools
+{
+    public static class RLSceneAnalyzer
+    {
+        public static List<RLSceneInfo> AnalyzeOpenScenes()
+        {
+            List<RLSceneInfo> results = new List<RLSceneInfo>();
+            for (int i = 0; i < SceneManager.sceneCount; i++)
+            {
+                Scene scene = SceneManager.GetSceneAt(i);
+                if (scene.IsValid() && scene.isLoaded)
+                {
+                    results.Add(AnalyzeLoadedScene(scene));
+                }
+            }
+            return results;
+        }
+
+        public static List<RLSceneInfo> AnalyzeBuildSettingsScenes()
+        {
+            List<string> paths = new List<string>();
+            foreach (EditorBuildSettingsScene scene in EditorBuildSettings.scenes)
+            {
+                if (scene.enabled)
+                {
+                    paths.Add(scene.path);
+                }
+            }
+            return AnalyzeScenePaths(paths);
+        }
+
+        public static List<RLSceneInfo> AnalyzeAllAssetScenes()
+        {
+            List<string> paths = new List<string>();
+            foreach (string guid in AssetDatabase.FindAssets("t:Scene"))
+            {
+                paths.Add(AssetDatabase.GUIDToAssetPath(guid));
+            }
+            return AnalyzeScenePaths(paths);
+        }
+
+        private static List<RLSceneInfo> AnalyzeScenePaths(List<string> paths)
+        {
+            List<RLSceneInfo> results = new List<RLSceneInfo>();
+            if (HasDirtyOpenScenes())
+            {
+                RLSceneInfo skipped = new RLSceneInfo();
+                skipped.sceneName = "Scene analysis skipped";
+                skipped.scenePath = "Open scenes contain unsaved changes";
+                skipped.notes = "The analyzer does not save scenes. Save or discard changes manually, then run scene analysis again.";
+                results.Add(skipped);
+                return results;
+            }
+
+            SceneSetup[] setup = EditorSceneManager.GetSceneManagerSetup();
+            try
+            {
+                foreach (string path in paths)
+                {
+                    if (string.IsNullOrEmpty(path))
+                    {
+                        continue;
+                    }
+
+                    Scene scene = EditorSceneManager.OpenScene(path, OpenSceneMode.Single);
+                    results.Add(AnalyzeLoadedScene(scene));
+                }
+            }
+            finally
+            {
+                if (setup != null && setup.Length > 0)
+                {
+                    EditorSceneManager.RestoreSceneManagerSetup(setup);
+                }
+            }
+
+            return results;
+        }
+
+        private static bool HasDirtyOpenScenes()
+        {
+            for (int i = 0; i < SceneManager.sceneCount; i++)
+            {
+                Scene scene = SceneManager.GetSceneAt(i);
+                if (scene.isDirty)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        private static RLSceneInfo AnalyzeLoadedScene(Scene scene)
+        {
+            RLSceneInfo info = new RLSceneInfo();
+            info.scenePath = scene.path;
+            info.sceneName = scene.name;
+            info.buildIndex = scene.buildIndex;
+            GameObject[] roots = scene.GetRootGameObjects();
+            info.rootGameObjectCount = roots.Length;
+
+            foreach (GameObject root in roots)
+            {
+                info.rootGameObjects.Add(root.name);
+                AnalyzeGameObjectRecursive(root, root.name, scene.path, info);
+            }
+
+            return info;
+        }
+
+        public static void AnalyzeGameObjectRecursive(GameObject gameObject, string hierarchyPath, string sourcePath, RLSceneInfo sceneInfo)
+        {
+            RLGameObjectInfo goInfo = AnalyzeGameObject(gameObject, hierarchyPath);
+            sceneInfo.gameObjects.Add(goInfo);
+            sceneInfo.totalGameObjects++;
+            if (gameObject.activeSelf) sceneInfo.activeGameObjects++;
+            else sceneInfo.inactiveGameObjects++;
+            sceneInfo.missingScriptCount += goInfo.missingScriptCount;
+            sceneInfo.missingReferenceCount += goInfo.missingReferenceCount;
+            sceneInfo.unityEvents.AddRange(RLUnityEventAnalyzer.ExtractUnityEvents(gameObject, sourcePath, hierarchyPath));
+
+            foreach (Transform child in gameObject.transform)
+            {
+                AnalyzeGameObjectRecursive(child.gameObject, hierarchyPath + "/" + child.name, sourcePath, sceneInfo);
+            }
+        }
+
+        public static RLGameObjectInfo AnalyzeGameObject(GameObject gameObject, string hierarchyPath)
+        {
+            RLGameObjectInfo info = new RLGameObjectInfo();
+            info.hierarchyPath = hierarchyPath;
+            info.activeSelf = gameObject.activeSelf;
+            info.tag = gameObject.tag;
+            info.layer = gameObject.layer;
+            info.missingScriptCount = GameObjectUtility.GetMonoBehavioursWithMissingScriptCount(gameObject);
+
+            Component[] components = gameObject.GetComponents<Component>();
+            foreach (Component component in components)
+            {
+                if (component == null)
+                {
+                    info.components.Add("Missing Script");
+                    continue;
+                }
+
+                info.components.Add(component.GetType().Name);
+                MonoBehaviour monoBehaviour = component as MonoBehaviour;
+                if (monoBehaviour != null)
+                {
+                    info.attachedScripts.Add(component.GetType().Name);
+                }
+
+                CollectSerializedReferences(component, info);
+            }
+
+            return info;
+        }
+
+        private static void CollectSerializedReferences(Component component, RLGameObjectInfo info)
+        {
+            SerializedObject serializedObject = new SerializedObject(component);
+            SerializedProperty property = serializedObject.GetIterator();
+            bool enterChildren = true;
+            while (property.NextVisible(enterChildren))
+            {
+                enterChildren = false;
+                if (property.propertyType != SerializedPropertyType.ObjectReference)
+                {
+                    continue;
+                }
+
+                if (property.objectReferenceValue != null)
+                {
+                    string referenceName = property.displayName + " -> " + property.objectReferenceValue.name;
+                    if (!info.referencedObjects.Contains(referenceName))
+                    {
+                        info.referencedObjects.Add(referenceName);
+                    }
+                }
+                else if (property.objectReferenceInstanceIDValue != 0)
+                {
+                    info.missingReferenceCount++;
+                }
+            }
+        }
+    }
+}