com.hidano.missing-reference-finder 1.0.0 → 1.1.0

package/Editor/MissingReferenceBuildCheck.cs

@@ -24,7 +24,7 @@ namespace Hidano.MissingReferenceFinder.Editor
     /// ログには「どのファイルの / どの GameObject (階層パス) の / 上から何番目のどのコンポーネントの / どのフィールド」が
     /// 壊れているかと、その対処法を出力する。Prefab インスタンス内のオブジェクトは元 Prefab を読み込んで名前を解決する。
     ///
-    /// 有効/無効はメニュー (Hidano/Tools/Check Missing References On Build) または
+    /// 有効/無効はメニュー (Tools/Hidano/Check Missing References On Build) または
     /// <see cref="MissingReferenceFinderWindow"/> から切り替えられる。
     /// </summary>
     public sealed class MissingReferenceBuildCheck : IPreprocessBuildWithReport
@@ -304,6 +304,7 @@ namespace Hidano.MissingReferenceFinder.Editor
         private static int CheckBuildScenes(out string breakdown)
         {
             var total = 0;
+            var unusedOverrideTotal = 0;
             var scenePaths = new List<string>();
             var prefabPaths = new List<string>();
             var prefabUsedBy = new Dictionary<string, List<string>>();
@@ -351,7 +352,7 @@ namespace Hidano.MissingReferenceFinder.Editor
                 foreach (var scenePath in scenePaths)
                 {
                     EditorUtility.DisplayProgressBar("Missing Reference Build Check", scenePath, (float)index++ / totalFiles);
-                    var count = CheckYamlFile(scenePath, true, null);
+                    var count = CheckYamlFile(scenePath, true, null, ref unusedOverrideTotal);
                     if (count > 0)
                     {
                         fileCounts.Add((scenePath, count));
@@ -363,7 +364,7 @@ namespace Hidano.MissingReferenceFinder.Editor
                 foreach (var prefabPath in prefabPaths)
                 {
                     EditorUtility.DisplayProgressBar("Missing Reference Build Check", prefabPath, (float)index++ / totalFiles);
-                    var count = CheckYamlFile(prefabPath, false, prefabUsedBy[prefabPath]);
+                    var count = CheckYamlFile(prefabPath, false, prefabUsedBy[prefabPath], ref unusedOverrideTotal);
                     if (count > 0)
                     {
                         fileCounts.Add((prefabPath, count));
@@ -392,6 +393,11 @@ namespace Hidano.MissingReferenceFinder.Editor
             breakdown = breakdownBuilder.Length > 0 ? breakdownBuilder.ToString() : "なし";
 
             var summary = $"{LogPrefix} 検査完了: {scenePaths.Count} シーン / {prefabPaths.Count} Prefab / Missing {total} 件";
+            if (unusedOverrideTotal > 0)
+            {
+                summary += $" / 未使用オーバーライド {unusedOverrideTotal} 件 (警告のみ・ビルドは継続)";
+            }
+
             if (total > 0)
             {
                 summary += $"\n内訳: {breakdown}";
@@ -452,8 +458,11 @@ namespace Hidano.MissingReferenceFinder.Editor
             public bool IsTransform => ClassId == TransformClassId || ClassId == RectTransformClassId;
         }
 
-        /// <summary>シーンまたは Prefab ファイルを 1 つ検査し、Missing の数を返す。</summary>
-        private static int CheckYamlFile(string assetPath, bool isScene, List<string> usedByScenes)
+        /// <summary>
+        /// シーンまたは Prefab ファイルを 1 つ検査し、Missing の数を返す。
+        /// 警告扱いにした未使用オーバーライドの数は <paramref name="unusedOverrideCount"/> に加算する。
+        /// </summary>
+        private static int CheckYamlFile(string assetPath, bool isScene, List<string> usedByScenes, ref int unusedOverrideCount)
         {
             var context = new FileContext(assetPath, isScene, ParseYamlFile(assetPath), usedByScenes);
 
@@ -462,6 +471,14 @@ namespace Hidano.MissingReferenceFinder.Editor
             {
                 foreach (var entry in doc.Missing)
                 {
+                    // 存在しないプロパティへのオーバーライドは Unity が適用しない (Inspector にも出ない) ので、ビルドは止めずに警告のみ
+                    if (context.IsUnusedOverride(doc, entry))
+                    {
+                        unusedOverrideCount++;
+                        Debug.LogWarning(context.BuildUnusedOverrideReport(doc, entry), context.GetContextObject(doc, entry));
+                        continue;
+                    }
+
                     count++;
                     Debug.LogError(context.BuildReport(doc, entry), context.GetContextObject(doc, entry));
                 }
@@ -1026,6 +1043,72 @@ namespace Hidano.MissingReferenceFinder.Editor
                     $"正しい{fieldTypeName ?? "アセット"}を設定し直すか、フィールドを右クリック → Revert でオーバーライドを解除して Prefab の値に戻してください。");
             }
 
+            /// <summary>
+            /// PrefabInstance のオーバーライドが、元 Prefab のコンポーネントに存在しないプロパティを指しているか。
+            /// フィールド名の変更 (例: Cinemachine 3 の CinemachineVolumeSettings で FocusTarget → m_FocusTarget) や
+            /// フィールド削除で取り残されたオーバーライドは Unity が適用せず Inspector にも表示されないため、
+            /// Inspector から設定し直しても消えず、参照先が消えたアセットでも実害がない。
+            /// 判定できない場合 (コンポーネントを読めない / 配列要素 / SerializeReference) は false (= Missing 扱い) にする。
+            /// </summary>
+            public bool IsUnusedOverride(DocumentInfo doc, MissingEntry entry)
+            {
+                if (doc.ClassId != PrefabInstanceClassId || entry.Key == SourcePrefabKey || entry.TargetFileId == 0)
+                {
+                    return false;
+                }
+
+                if (!(PrefabAssetCache.GetObject(doc.SourcePrefabGuid, entry.TargetFileId) is Component target))
+                {
+                    return false;
+                }
+
+                var propertyPath = entry.Key;
+                if (propertyPath.StartsWith("managedReferences", StringComparison.Ordinal))
+                {
+                    return false;
+                }
+
+                // 配列要素はインスタンス側でサイズが拡張されている場合があるため、配列プロパティ自体の存在だけを確認する
+                var arrayIndex = propertyPath.IndexOf(".Array.data[", StringComparison.Ordinal);
+                if (arrayIndex >= 0)
+                {
+                    propertyPath = propertyPath.Substring(0, arrayIndex);
+                }
+
+                try
+                {
+                    using var serializedObject = new SerializedObject(target);
+                    return serializedObject.FindProperty(propertyPath) == null;
+                }
+                catch (Exception)
+                {
+                    return false;
+                }
+            }
+
+            public string BuildUnusedOverrideReport(DocumentInfo instance, MissingEntry entry)
+            {
+                var targetComponent = (Component)PrefabAssetCache.GetObject(instance.SourcePrefabGuid, entry.TargetFileId);
+                AssetDatabase.TryGetGUIDAndLocalFileIdentifier(targetComponent.gameObject, out _, out long gameObjectLocalId);
+                var ownerPath = GetPrefabInstanceObjectPath(instance, gameObjectLocalId, 0);
+                var typeName = targetComponent.GetType().Name;
+                var sourcePrefabPath = PrefabAssetCache.GetPath(instance.SourcePrefabGuid) ?? instance.SourcePrefabGuid;
+                var location = _isScene
+                    ? $"シーン {_fileLabel} を開き、Hierarchy で上記 Prefab インスタンスを右クリック"
+                    : $"Prefab {_fileLabel} を開き、Hierarchy で上記 Prefab インスタンスを右クリック";
+
+                return Compose(
+                    $"[Unused Override] {_fileLabel} | {ownerPath} | {typeName} | {entry.Key} (存在しないプロパティへのオーバーライド)",
+                    "ファイル: " + _assetPath,
+                    DescribeUsedBy(),
+                    $"GameObject: {ownerPath} (Prefab {sourcePrefabPath} のインスタンス)",
+                    "コンポーネント: " + typeName,
+                    $"プロパティ: {entry.Key} は {typeName} に存在しません (フィールド名の変更・削除で取り残されたオーバーライド)",
+                    DescribeGuid(entry.Guid),
+                    "影響: このオーバーライドは Unity に適用されず Inspector にも表示されないため、ビルドは止めません。",
+                    $"対処: {location} → Prefab → Remove Unused Overrides でファイルから削除できます。");
+            }
+
             private string OpenInstruction => _isScene
                 ? $"シーン {_fileLabel} を開いて"
                 : $"Prefab {_fileLabel} を Project ウィンドウでダブルクリックして開き、";

package/Editor/MissingReferenceFinderWindow.cs

@@ -9,7 +9,7 @@ namespace Hidano.MissingReferenceFinder.Editor
     /// </summary>
     public sealed class MissingReferenceFinderWindow : EditorWindow
     {
-        private const string MenuPath = "Hidano/Tools/Missing Reference Finder";
+        private const string MenuPath = "Tools/Hidano/Missing Reference Finder";
 
         [SerializeField] private bool _reportNone = true;
         [SerializeField] private bool _monoBehaviourOnly = true;

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/package.json

@@ -1,8 +1,8 @@
 {
   "name": "com.hidano.missing-reference-finder",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "displayName": "Missing Reference Finder",
-  "description": "A tool to find missing references in Unity projects.",
+  "description": "A tool to find missing references in Unity projects. Also fills empty PlayableDirector binding entries when a Timeline is saved, so they are committed together with the Timeline change.",
   "unity": "6000.0",
   "author": {
     "name": "Hidano"