Add "Dirt" plugin

Assets/Scripts/Editor/Dirt/ModificationReference.cs

@@ -0,0 +1,213 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+using UnityEditor;
+using UnityEngine;
+
+namespace Dirt
+{
+    public class ModificationReference
+    {
+        GameObject owner;
+        Object target;
+
+        public string targetPath { get; private set; }
+        public List<int> targetIndexedPath { get; private set; }
+        public string targetPropertyValue { get; private set; }
+        public bool hasTargetPropertyObjectValue { get; private set; }
+        public Object targetPropertyObjectValue { get; private set; }
+        public bool isNothing { get; private set; }
+        public bool hasValue { get; private set; }
+
+        public ModificationReference(GameObject owner, Object target)
+        {
+            SetOwner(owner);
+            SetTarget(target);
+        }
+
+        public void SetOwner(GameObject owner)
+        {
+            this.owner = owner;
+        }
+
+        public GameObject GetOwner()
+        {
+            if (!owner)
+            {
+                Debug.LogWarning("Reference has no owner");
+            }
+
+            return owner;
+        }
+        
+        public List<Object> GetOwnerHierarchy()
+        {
+            var scenes = AssetDatabase.FindAssets("t:scene")
+                .Select(AssetDatabase.GUIDToAssetPath)
+                .Select(AssetDatabase.LoadAssetAtPath<SceneAsset>)
+                .ToList();
+
+            var hierarchy = new List<Object>();
+
+            var current = GetOwner();
+
+            if (current)
+            {
+                var scene = current.scene;
+                
+                hierarchy.Add(current);
+
+                while (current)
+                {   
+                    var parent = current.transform.parent;
+
+                    if (parent)
+                    {
+                        current = parent.gameObject;
+                        hierarchy.Add(current);
+                    }
+
+                    break;
+                }
+
+                if (scene.IsValid())
+                {
+                    hierarchy.Add(scenes.FirstOrDefault(x => x.name == scene.name));
+                }
+            }
+
+            hierarchy.Reverse();
+
+            return hierarchy;
+        }
+
+        public void SetTarget(Object target)
+        {
+            this.target = target;
+        }
+
+        public Object GetTarget()
+        {
+            if (!target)
+            {
+                Debug.LogWarning($"{(owner ? $"{owner.name}: " : "")}Reference has no target");
+            }
+
+            return target;
+        }
+
+        public SerializedProperty GetTargetProperty(Modification modification)
+        {
+            var target = GetTarget();
+            if (!target)
+            {
+                return null;
+            }
+
+            var prefabObject = new SerializedObject(target);
+            return prefabObject.FindProperty(modification.propertyPath);
+        }
+
+        public int Setup(Modification modification)
+        {
+            var componentIndex = -1;
+
+            var owner = GetOwner();
+            var target = GetTarget();
+
+            if (owner && target)
+            {
+                var parent = target is Transform transform
+                    ? transform
+                    : target is GameObject gameObject
+                        ? gameObject.transform
+                        : (target as Component).transform;
+
+                var components = parent.GetComponents<Component>();
+                componentIndex = ArrayUtility.IndexOf(components, target);
+
+                var path = new List<string>();
+                targetIndexedPath = new List<int>();
+
+                while (parent && parent != owner.transform)
+                {
+                    path.Insert(0, parent.name);
+                    targetIndexedPath.Insert(0, parent.GetSiblingIndex());
+                    parent = parent.parent;
+                }
+
+                targetPath = string.Join("/", path);
+            }
+            else
+            {
+                targetPath = string.Empty;
+            }
+
+            var p = GetTargetProperty(modification);
+            string v;
+
+            if (p is null)
+            {
+                isNothing = true;
+                v = "<color=#777777>(nothing)</color>";
+            }
+            else
+            {
+                hasValue = true;
+
+                switch (p.type)
+                {
+                    case "bool":
+                        v = $"<color=#9999ff>{p.boolValue}</color>";
+                        break;
+
+                    case "short":
+                    case "int":
+                    case "uint":
+                        v = $"<color=#33ff33>{p.intValue}</color>";
+                        break;
+
+                    case "float":
+                        v = $"<color=#99ff99>{p.floatValue:0.00}</color>";
+                        break;
+
+                    case "string":
+                        v = p.stringValue == string.Empty
+                            ? $"<color=#cc9900>(empty)</color>"
+                            : $"<color=#ffcc66>{p.stringValue}</color>";
+                        break;
+
+                    case "Enum":
+                        if (0 <= p.enumValueIndex && p.enumValueIndex < p.enumNames.Length)
+                            v = $"<color=#ffff00>{p.enumNames[p.enumValueIndex]}</color>";
+                        else
+                            v = $"<color=#ffff00>[type Enum] {p.enumValueIndex}</color>";
+                        break;
+
+                    case "ArraySize":
+                        v = p.intValue.ToString();
+                        break;
+
+                    default:
+                        if (Regex.IsMatch(p.type, @"^PPtr\<.+\>$"))
+                        {
+                            hasTargetPropertyObjectValue = true;
+                            targetPropertyObjectValue = p.objectReferenceValue;
+                            v = string.Empty;
+                            break;
+                        }
+
+                        v = $"[type {p.type}]";
+                        v = $"<color=#999999>{v}</color>";
+                        hasValue = false;
+                        break;
+                }
+            }
+
+            targetPropertyValue = v;
+
+            return componentIndex;
+        }
+    }
+}