private void SetDiffSelected(GameObjectDiff.Diff diff, bool selected)
 {
     if (selected)
     {
         _selectedDiffs.Add(diff.id);
         _deselectedDiffs.Remove(diff.id);
     }
     else
     {
         _selectedDiffs.Remove(diff.id);
         _deselectedDiffs.Add(diff.id);
     }
 }
 private bool IsDiffSelected(GameObjectDiff.Diff diff)
 {
     return(selectAllByDefault ? !_deselectedDiffs.Contains(diff.id) : _selectedDiffs.Contains(diff.id));
 }
Пример #3
0
        public static List <Diff> GetDiffs(GameObject instance, GameObject instanceRoot, GameObject prefab, GameObject prefabRoot)
        {
            List <Diff> diffs = new List <Diff>();

            if (prefab)
            {
                // compare existing components
                var prefabComponents  = prefab.GetComponents <Component>();
                var deletedComponents = new List <Component>();
                foreach (var prefabComponent in prefabComponents)
                {
                    var       instanceComponentsOfType = instance.GetComponents(prefabComponent.GetType());
                    Component instanceComponent        = instanceComponentsOfType.Length > 0 ? instanceComponentsOfType[0] : null;

                    // if we have more than one same component -> try to get the same by order of GetComponents()
                    if (instanceComponentsOfType.Length > 1)
                    {
                        int indexInPrefab = Array.IndexOf(prefab.GetComponents(prefabComponent.GetType()), prefabComponent);
                        instanceComponent = instanceComponentsOfType[indexInPrefab % instanceComponentsOfType.Length];
                    }

                    if (instanceComponent)
                    {
                        FillDiffsFromComponent(ref diffs, instanceComponent, prefabComponent, instanceRoot, prefabRoot);
                    }
                    else
                    {
                        deletedComponents.Add(prefabComponent);
                    }
                }

                // delete obsolete components
                foreach (var deletedComponent in deletedComponents)
                {
                    Component prefabDeletedComponent = deletedComponent;
                    Diff      deleteDiff             = new Diff(Diff.Operation.Delete, prefabDeletedComponent, null);
                    deleteDiff.Apply = () => { GameObject.DestroyImmediate(prefabDeletedComponent, true); };
                    deleteDiff.OnGUI = () =>
                    {
                        GUI.color = new Color(1, 0.7f, 0.7f);
                        EditorGUILayout.LabelField("Deleted component:", prefabDeletedComponent.GetType().Name);
                        GUI.color = Color.white;
                        EditorGUILayout.ObjectField(prefabDeletedComponent, typeof(Component), false);
                    };
                    diffs.Add(deleteDiff);
                }

                // add new components
                var instanceComponents = instance.GetComponents <Component>();
                foreach (var instanceComponent in instanceComponents)
                {
                    if (!System.Array.Find <Component>(prefabComponents, (x) => { return(x.GetType() == instanceComponent.GetType()); }))
                    {
                        Component instanceNewComponent = instanceComponent;
                        Diff      addDiff = new Diff(Diff.Operation.Add, instanceNewComponent, null);
                        addDiff.Apply = () => {
                            var prefabComponent = prefab.AddComponent(instanceNewComponent.GetType());
                            UnityEditor.EditorUtility.CopySerialized(instanceNewComponent, prefabComponent);
                        };
                        addDiff.OnGUI = () =>
                        {
                            GUI.color = new Color(0.7f, 1, 0.7f);
                            EditorGUILayout.LabelField("Added component:", instanceNewComponent.GetType().Name);
                            GUI.color = Color.white;
                            EditorGUILayout.ObjectField(instanceNewComponent, typeof(Component), false);
                        };
                        diffs.Add(addDiff);
                    }
                }
            }
            else
            {
                // probably new gameobject
                GameObjectDiff.Diff d = new GameObjectDiff.Diff(GameObjectDiff.Diff.Operation.New, null, instance.name);
                d.Apply = () =>
                {
                    GameObject prefabInstance = PrefabUtility.InstantiatePrefab(prefabRoot) as GameObject;
                    GameObject instanceCopy   = new GameObject(instance.name);
                    string     path           = EditorUtils.GetPathForObjectInHierarchy(instance, instanceRoot);
                    instanceCopy.transform.parent = prefabInstance.GetChildByPath(path).transform;
                    foreach (Component c in instance.GetComponents <Component>())
                    {
                        if (c is Transform)
                        {
                            continue;
                        }
                        EditorUtility.CopySerialized(c, instanceCopy.AddComponent(c.GetType()));
                    }
                    EditorUtility.CopySerialized(instance.transform, instanceCopy.transform);
                    PrefabUtility.ReplacePrefab(prefabInstance, prefabRoot);
                    GameObject.DestroyImmediate(prefabInstance);
                };
                d.OnGUI = () =>
                {
                    GUI.color = new Color(0, 1f, 0);
                    EditorGUILayout.LabelField("New GameObject:", instance.name);
                    GUI.color = Color.white;
                };
                diffs.Add(d);
            }

            return(diffs);
        }