com.hidano.missing-reference-finder 0.0.0-stage → 1.0.0

package/Editor/MissingReferenceBuildCheck.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 719e79c6f9cf4e65a50bec0f69b512f4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Editor/MissingReferenceFinderWindow.cs

@@ -0,0 +1,79 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Hidano.MissingReferenceFinder.Editor
+{
+    /// <summary>
+    /// <see cref="MissingReferenceScanner"/> を手動実行するためのウィンドウ。
+    /// 現在開いている全シーンを対象に Missing / None の参照を Console に出力する。
+    /// </summary>
+    public sealed class MissingReferenceFinderWindow : EditorWindow
+    {
+        private const string MenuPath = "Hidano/Tools/Missing Reference Finder";
+
+        [SerializeField] private bool _reportNone = true;
+        [SerializeField] private bool _monoBehaviourOnly = true;
+        [SerializeField] private bool _includeInactive = true;
+
+        [MenuItem(MenuPath)]
+        private static void Open()
+        {
+            var window = GetWindow<MissingReferenceFinderWindow>();
+            window.titleContent = new GUIContent("Missing Ref Finder");
+            window.minSize = new Vector2(320f, 200f);
+        }
+
+        private void OnGUI()
+        {
+            EditorGUILayout.HelpBox(
+                "現在開いている全シーンのコンポーネントを走査し、Missing / None の参照を Console に出力します。\n" +
+                "Console のログをクリックすると該当 GameObject が Hierarchy 上でハイライトされます。",
+                MessageType.Info);
+
+            EditorGUILayout.Space();
+
+            _reportNone = EditorGUILayout.ToggleLeft(
+                new GUIContent("None も報告する", "OFF の場合は Missing (参照先が消失したもの) のみ報告します。"),
+                _reportNone);
+            _monoBehaviourOnly = EditorGUILayout.ToggleLeft(
+                new GUIContent("MonoBehaviour のみ", "OFF の場合は Renderer や Camera などの組み込みコンポーネントも検査します。"),
+                _monoBehaviourOnly);
+            _includeInactive = EditorGUILayout.ToggleLeft(
+                new GUIContent("非アクティブな GameObject も含める"),
+                _includeInactive);
+
+            EditorGUILayout.Space();
+
+            if (GUILayout.Button("検索してConsoleに出力", GUILayout.Height(32f)))
+            {
+                Scan();
+            }
+
+            EditorGUILayout.Space();
+
+            var buildCheckEnabled = EditorGUILayout.ToggleLeft(
+                new GUIContent(
+                    "ビルド時に Missing をチェックしてビルドを中止する",
+                    "ビルド開始前に Build Settings の各シーンファイルを読み、存在しないアセットへの参照 (Missing) があればビルドを失敗させます。"),
+                MissingReferenceBuildCheck.Enabled);
+            if (buildCheckEnabled != MissingReferenceBuildCheck.Enabled)
+            {
+                MissingReferenceBuildCheck.Enabled = buildCheckEnabled;
+            }
+        }
+
+        private void Scan()
+        {
+            var options = new MissingReferenceScanner.Options
+            {
+                ReportNone = _reportNone,
+                MonoBehaviourOnly = _monoBehaviourOnly,
+                IncludeInactive = _includeInactive,
+                ShowProgressBar = true,
+            };
+
+            var result = MissingReferenceScanner.ScanLoadedScenes(options);
+            Debug.Log(MissingReferenceScanner.FormatSummary("[MissingReferenceFinder]", result, _reportNone));
+        }
+    }
+}

package/Editor/MissingReferenceFinderWindow.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c5a81bb13e5d4df48f5966f1e735a512
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Editor/MissingReferenceScanner.cs

@@ -0,0 +1,256 @@
+using System.Collections.Generic;
+using System.Text;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace Hidano.MissingReferenceFinder.Editor
+{
+    /// <summary>
+    /// シーン内のコンポーネントを走査し、Serialize されたオブジェクト参照の Missing / None を Console に出力する。
+    /// ログは 1 パラメータ 1 行で出力し、context に GameObject を渡すので Console でクリックすると Hierarchy 上でハイライトされる。
+    /// <see cref="MissingReferenceFinderWindow"/> から呼び出す。
+    /// ビルド時のチェックはシーンファイルを直接読む <see cref="MissingReferenceBuildCheck"/> が担当する。
+    /// </summary>
+    public static class MissingReferenceScanner
+    {
+        public struct Options
+        {
+            /// <summary>None (未設定) も報告するか。</summary>
+            public bool ReportNone;
+
+            /// <summary>MonoBehaviour のみを対象にするか。false の場合は組み込みコンポーネントも検査する。</summary>
+            public bool MonoBehaviourOnly;
+
+            /// <summary>非アクティブな GameObject も対象にするか。</summary>
+            public bool IncludeInactive;
+
+            /// <summary>進捗バーを表示するか。</summary>
+            public bool ShowProgressBar;
+        }
+
+        public struct Result
+        {
+            public int ComponentCount;
+            public int MissingCount;
+            public int MissingScriptCount;
+            public int NoneCount;
+
+            /// <summary>Missing 参照または Missing Script が 1 件でもあれば true。</summary>
+            public bool HasMissing => MissingCount > 0 || MissingScriptCount > 0;
+
+            public void Add(in Result other)
+            {
+                ComponentCount += other.ComponentCount;
+                MissingCount += other.MissingCount;
+                MissingScriptCount += other.MissingScriptCount;
+                NoneCount += other.NoneCount;
+            }
+        }
+
+        /// <summary>
+        /// Unity が内部管理用に持つ参照フィールド。ユーザーが設定するものではないので検査対象から除外する。
+        /// </summary>
+        private static readonly HashSet<string> IgnoredPropertyPaths = new HashSet<string>
+        {
+            "m_Script",
+            "m_GameObject",
+            "m_CorrespondingSourceObject",
+            "m_PrefabInstance",
+            "m_PrefabAsset",
+            "m_EditorClassIdentifier",
+        };
+
+        /// <summary>現在ロードされている全シーンを走査する。</summary>
+        public static Result ScanLoadedScenes(in Options options)
+        {
+            var total = new Result();
+            try
+            {
+                for (var sceneIndex = 0; sceneIndex < SceneManager.sceneCount; sceneIndex++)
+                {
+                    var scene = SceneManager.GetSceneAt(sceneIndex);
+                    if (!scene.isLoaded)
+                    {
+                        continue;
+                    }
+
+                    total.Add(ScanScene(scene, options));
+                }
+            }
+            finally
+            {
+                if (options.ShowProgressBar)
+                {
+                    EditorUtility.ClearProgressBar();
+                }
+            }
+
+            return total;
+        }
+
+        /// <summary>指定したシーンを走査する。</summary>
+        public static Result ScanScene(Scene scene, in Options options)
+        {
+            var result = new Result();
+            var roots = scene.GetRootGameObjects();
+
+            try
+            {
+                for (var rootIndex = 0; rootIndex < roots.Length; rootIndex++)
+                {
+                    var root = roots[rootIndex];
+                    if (options.ShowProgressBar)
+                    {
+                        EditorUtility.DisplayProgressBar(
+                            "Missing Reference Finder",
+                            $"{scene.name} : {root.name}",
+                            (float)rootIndex / roots.Length);
+                    }
+
+                    var components = root.GetComponentsInChildren<Component>(true);
+                    foreach (var component in components)
+                    {
+                        // component が null なのはスクリプト自体が Missing になっているケース。
+                        // GetComponentsInChildren では所属 GameObject を辿れないため、GameObject 単位で別途検出する。
+                        if (component == null)
+                        {
+                            continue;
+                        }
+
+                        if (!options.IncludeInactive && !component.gameObject.activeInHierarchy)
+                        {
+                            continue;
+                        }
+
+                        if (options.MonoBehaviourOnly && !(component is MonoBehaviour))
+                        {
+                            continue;
+                        }
+
+                        result.ComponentCount++;
+                        ScanComponent(component, options.ReportNone, ref result);
+                    }
+
+                    result.MissingScriptCount += ReportMissingScripts(root);
+                }
+            }
+            finally
+            {
+                if (options.ShowProgressBar)
+                {
+                    EditorUtility.ClearProgressBar();
+                }
+            }
+
+            return result;
+        }
+
+        public static string FormatSummary(string prefix, in Result result, bool includeNone)
+        {
+            var summary = new StringBuilder();
+            summary.Append(prefix).Append(" 検査完了: ");
+            summary.Append(result.ComponentCount).Append(" コンポーネント / Missing ");
+            summary.Append(result.MissingCount).Append(" 件 / Missing Script ");
+            summary.Append(result.MissingScriptCount).Append(" 件");
+            if (includeNone)
+            {
+                summary.Append(" / None ").Append(result.NoneCount).Append(" 件");
+            }
+
+            return summary.ToString();
+        }
+
+        private static void ScanComponent(Component component, bool reportNone, ref Result result)
+        {
+            var serializedObject = new SerializedObject(component);
+            var property = serializedObject.GetIterator();
+
+            var enterChildren = true;
+            while (property.Next(enterChildren))
+            {
+                enterChildren = true;
+
+                // 文字列の子要素へは潜らない
+                if (property.propertyType == SerializedPropertyType.String)
+                {
+                    enterChildren = false;
+                }
+
+                if (property.propertyType != SerializedPropertyType.ObjectReference)
+                {
+                    continue;
+                }
+
+                if (IgnoredPropertyPaths.Contains(property.propertyPath))
+                {
+                    continue;
+                }
+
+                if (property.objectReferenceValue != null)
+                {
+                    continue;
+                }
+
+                // 参照先の instanceID が残っているのに解決できない = Missing
+                var isMissing = property.objectReferenceInstanceIDValue != 0;
+                if (isMissing)
+                {
+                    result.MissingCount++;
+                    Debug.LogError(FormatMessage("Missing", component, property), component.gameObject);
+                }
+                else if (reportNone)
+                {
+                    result.NoneCount++;
+                    Debug.LogWarning(FormatMessage("None", component, property), component.gameObject);
+                }
+            }
+        }
+
+        private static int ReportMissingScripts(GameObject root)
+        {
+            var count = 0;
+            var transforms = root.GetComponentsInChildren<Transform>(true);
+            foreach (var transform in transforms)
+            {
+                var gameObject = transform.gameObject;
+                var missing = GameObjectUtility.GetMonoBehavioursWithMissingScriptCount(gameObject);
+                for (var i = 0; i < missing; i++)
+                {
+                    count++;
+                    Debug.LogError(
+                        $"[Missing Script] {GetHierarchyPath(gameObject)} にスクリプトが見つからないコンポーネントがあります。",
+                        gameObject);
+                }
+            }
+
+            return count;
+        }
+
+        private static string FormatMessage(string kind, Component component, SerializedProperty property)
+        {
+            var typeName = property.type;
+            // "PPtr<$Transform>" のような表記から型名だけを取り出す
+            if (typeName.StartsWith("PPtr<$") && typeName.EndsWith(">"))
+            {
+                typeName = typeName.Substring(6, typeName.Length - 7);
+            }
+
+            return $"[{kind}] {GetHierarchyPath(component.gameObject)} <{component.GetType().Name}> " +
+                   $"{property.propertyPath} ({typeName})";
+        }
+
+        private static string GetHierarchyPath(GameObject gameObject)
+        {
+            var path = new StringBuilder(gameObject.name);
+            var parent = gameObject.transform.parent;
+            while (parent != null)
+            {
+                path.Insert(0, '/').Insert(0, parent.name);
+                parent = parent.parent;
+            }
+
+            return $"{gameObject.scene.name}:{path}";
+        }
+    }
+}

package/Editor/MissingReferenceScanner.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 44adc4eaf26b458182e0a3024c6823a7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Editor.meta

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

package/package.json

@@ -1,6 +1,13 @@
 {
   "name": "com.hidano.missing-reference-finder",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "displayName": "Missing Reference Finder",
+  "description": "A tool to find missing references in Unity projects.",
+  "unity": "6000.0",
+  "author": {
+    "name": "Hidano"
+  },
+  "dependencies": {
+  },
+  "license": "MIT"
+}

package/package.json.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 4561b82b786937b408bdc3f066bb7beb
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.