com.hidano.missing-reference-finder 0.0.0-stage → 1.1.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 = "Tools/Hidano/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/TimelineBindings/TimelineBindingEntryFiller.cs

@@ -0,0 +1,274 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.Playables;
+using UnityEngine.SceneManagement;
+using Object = UnityEngine.Object;
+
+namespace Hidano.MissingReferenceFinder.Editor.TimelineBindings
+{
+    /// <summary>
+    /// Timeline (.playable) の保存時に、その Timeline を再生する PlayableDirector の m_SceneBindings へ
+    /// 未登録トラックの空 Binding (value: None) を追加する。
+    ///
+    /// PlayableDirector の Inspector は Bindings 欄を表示した時点で、未登録の出力に空の Binding を作る
+    /// (UnityEditor.DirectorEditor.UpdatePlayableBindingsIfRequired)。トラックを追加した人がその Prefab の
+    /// Inspector を表示していないと、後で別の人が表示したときに意図しない差分として現れる。その差分をコミットせずに
+    /// 抱えたまま pull すると、コンフリクト解決時に他の人が設定した Binding を上書きして消す事故につながる。
+    /// トラック追加と同じタイミングで空 Binding を作っておき、同じコミットに含めることでこれを防ぐ。
+    ///
+    /// 対象は Inspector と同じく、playableAsset.outputs のうち出力先の型を持つもの。Inspector は出力先の型を持たない
+    /// 出力の Binding を削除もするが、要素の位置がずれて Prefab インスタンスのオーバーライド (配列番号で記録される) を
+    /// 崩しうるため、ここでは末尾への追加のみを行う。Prefab インスタンス上の PlayableDirector は
+    /// 元 Prefab 側で処理されるので対象外 (インスタンス側に追加すると不要なオーバーライドになる)。
+    ///
+    /// 有効/無効はメニュー (Tools/Hidano/Fill Timeline Binding Entries On Save) で切り替えられる。
+    /// </summary>
+    public sealed class TimelineBindingEntryFiller : AssetPostprocessor
+    {
+        private const string ToggleMenuPath = "Tools/Hidano/Fill Timeline Binding Entries On Save";
+        private const string RunMenuPath = "Tools/Hidano/Fill Timeline Binding Entries In All Prefabs";
+        private const string EditorPrefsKey = "Hidano.TimelineBindingEntryFiller.Enabled";
+        private const string LogPrefix = "[TimelineBindingEntryFiller]";
+
+        private const string PlayableExtension = ".playable";
+        private const string AssetsFolder = "Assets";
+        private const string SceneBindingsProperty = "m_SceneBindings";
+        private const string BindingKeyProperty = "key";
+        private const string BindingValueProperty = "value";
+
+        /// <summary>delayCall 待ちの間に保存された Timeline のパス。</summary>
+        private static readonly HashSet<string> PendingTimelinePaths = new HashSet<string>();
+
+        public static bool Enabled
+        {
+            get => EditorPrefs.GetBool(EditorPrefsKey, true);
+            set => EditorPrefs.SetBool(EditorPrefsKey, value);
+        }
+
+        [MenuItem(ToggleMenuPath)]
+        private static void ToggleEnabled()
+        {
+            Enabled = !Enabled;
+        }
+
+        [MenuItem(ToggleMenuPath, true)]
+        private static bool ToggleEnabledValidate()
+        {
+            Menu.SetChecked(ToggleMenuPath, Enabled);
+            return true;
+        }
+
+        /// <summary>保存を待たずに、Timeline を参照する全 Prefab と開いているシーンに同じ処理を行う。</summary>
+        [MenuItem(RunMenuPath)]
+        private static void RunManually()
+        {
+            var addedCount = Fill(_ => true);
+            if (addedCount == 0)
+            {
+                Debug.Log($"{LogPrefix} 追加が必要な Binding はありませんでした。");
+            }
+        }
+
+        private static void OnPostprocessAllAssets(
+            string[] importedAssets,
+            string[] deletedAssets,
+            string[] movedAssets,
+            string[] movedFromAssetPaths)
+        {
+            if (!Enabled)
+            {
+                return;
+            }
+
+            var added = false;
+            foreach (var path in importedAssets)
+            {
+                if (IsProjectTimelinePath(path))
+                {
+                    added |= PendingTimelinePaths.Add(path);
+                }
+            }
+
+            if (added)
+            {
+                // インポート処理中に他のアセットを書き換えないよう、インポート完了後に回す
+                EditorApplication.delayCall -= ProcessPending;
+                EditorApplication.delayCall += ProcessPending;
+            }
+        }
+
+        private static bool IsProjectTimelinePath(string path)
+        {
+            return path.StartsWith(AssetsFolder + "/", StringComparison.Ordinal) &&
+                   path.EndsWith(PlayableExtension, StringComparison.OrdinalIgnoreCase);
+        }
+
+        private static void ProcessPending()
+        {
+            if (PendingTimelinePaths.Count == 0)
+            {
+                return;
+            }
+
+            var timelinePaths = new HashSet<string>(PendingTimelinePaths);
+            PendingTimelinePaths.Clear();
+            Fill(timelinePaths.Contains);
+        }
+
+        /// <summary>
+        /// <paramref name="isTargetTimeline"/> に該当する Timeline を参照する Prefab と、開いているシーンを処理する。
+        /// </summary>
+        /// <returns>追加した Binding の総数。</returns>
+        private static int Fill(Func<string, bool> isTargetTimeline)
+        {
+            var addedCount = 0;
+            var prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
+
+            foreach (var guid in AssetDatabase.FindAssets("t:Prefab", new[] { AssetsFolder }))
+            {
+                var prefabPath = AssetDatabase.GUIDToAssetPath(guid);
+                var referencesTarget = AssetDatabase.GetDependencies(prefabPath, false)
+                    .Any(path => IsProjectTimelinePath(path) && isTargetTimeline(path));
+                if (!referencesTarget)
+                {
+                    continue;
+                }
+
+                // Prefab モードで開いている Prefab をファイル側から書き換えると編集中の内容と食い違うので、ステージ上で処理する
+                if (prefabStage != null && prefabStage.assetPath == prefabPath)
+                {
+                    var stageAdded = FillDirectors(prefabStage.prefabContentsRoot, isTargetTimeline, prefabPath);
+                    if (stageAdded > 0)
+                    {
+                        EditorSceneManager.MarkSceneDirty(prefabStage.scene);
+                        addedCount += stageAdded;
+                    }
+
+                    continue;
+                }
+
+                var root = PrefabUtility.LoadPrefabContents(prefabPath);
+                try
+                {
+                    var prefabAdded = FillDirectors(root, isTargetTimeline, prefabPath);
+                    if (prefabAdded > 0)
+                    {
+                        PrefabUtility.SaveAsPrefabAsset(root, prefabPath);
+                        addedCount += prefabAdded;
+                    }
+                }
+                finally
+                {
+                    PrefabUtility.UnloadPrefabContents(root);
+                }
+            }
+
+            for (var i = 0; i < SceneManager.sceneCount; i++)
+            {
+                var scene = SceneManager.GetSceneAt(i);
+                if (!scene.isLoaded)
+                {
+                    continue;
+                }
+
+                var sceneAdded = scene.GetRootGameObjects()
+                    .Sum(root => FillDirectors(root, isTargetTimeline, scene.path));
+                if (sceneAdded > 0)
+                {
+                    EditorSceneManager.MarkSceneDirty(scene);
+                    addedCount += sceneAdded;
+                }
+            }
+
+            return addedCount;
+        }
+
+        private static int FillDirectors(GameObject root, Func<string, bool> isTargetTimeline, string context)
+        {
+            var addedCount = 0;
+            foreach (var director in root.GetComponentsInChildren<PlayableDirector>(true))
+            {
+                if (PrefabUtility.IsPartOfPrefabInstance(director))
+                {
+                    continue;
+                }
+
+                var playableAsset = director.playableAsset;
+                if (playableAsset == null || !isTargetTimeline(AssetDatabase.GetAssetPath(playableAsset)))
+                {
+                    continue;
+                }
+
+                var addedKeys = FillDirector(director, playableAsset);
+                if (addedKeys.Count == 0)
+                {
+                    continue;
+                }
+
+                addedCount += addedKeys.Count;
+                Debug.Log(
+                    $"{LogPrefix} {context} の {GetHierarchyPath(director.transform)} に空の Binding を {addedKeys.Count} 件追加しました " +
+                    $"({playableAsset.name}: {string.Join(", ", addedKeys.Select(key => key.name))})。" +
+                    "Timeline の変更と一緒にコミットしてください。");
+            }
+
+            return addedCount;
+        }
+
+        /// <summary>
+        /// 出力先の型を持つ出力のうち m_SceneBindings に無いものを、value が None の要素として末尾に追加する。
+        /// UnityEditor.DirectorEditor.UpdatePlayableBindingsIfRequired と同じ対象・同じ順序になる。
+        /// </summary>
+        private static List<Object> FillDirector(PlayableDirector director, PlayableAsset playableAsset)
+        {
+            var serializedDirector = new SerializedObject(director);
+            var bindings = serializedDirector.FindProperty(SceneBindingsProperty);
+
+            var boundKeys = new HashSet<Object>();
+            for (var i = 0; i < bindings.arraySize; i++)
+            {
+                boundKeys.Add(bindings.GetArrayElementAtIndex(i).FindPropertyRelative(BindingKeyProperty).objectReferenceValue);
+            }
+
+            var addedKeys = new List<Object>();
+            foreach (var output in playableAsset.outputs)
+            {
+                var key = output.sourceObject;
+                if (key == null || output.outputTargetType == null || !boundKeys.Add(key))
+                {
+                    continue;
+                }
+
+                var index = bindings.arraySize;
+                bindings.InsertArrayElementAtIndex(index);
+                var element = bindings.GetArrayElementAtIndex(index);
+                element.FindPropertyRelative(BindingKeyProperty).objectReferenceValue = key;
+                element.FindPropertyRelative(BindingValueProperty).objectReferenceValue = null;
+                addedKeys.Add(key);
+            }
+
+            if (addedKeys.Count > 0)
+            {
+                serializedDirector.ApplyModifiedPropertiesWithoutUndo();
+            }
+
+            return addedKeys;
+        }
+
+        private static string GetHierarchyPath(Transform transform)
+        {
+            var builder = new StringBuilder(transform.name);
+            for (var parent = transform.parent; parent != null; parent = parent.parent)
+            {
+                builder.Insert(0, parent.name + "/");
+            }
+
+            return builder.ToString();
+        }
+    }
+}

package/Editor/TimelineBindings/TimelineBindingEntryFiller.cs.meta

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

package/Editor/TimelineBindings.meta

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

package/Editor.meta

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