feat: improve performance

Author: SolarianZ

Editor/Scripts/GraphView/PlayableGraphView.cs

@@ -1,7 +1,6 @@
 using GBG.PlayableGraphMonitor.Editor.Node;
 using System.Collections.Generic;
 using UnityEditor.Experimental.GraphView;
-using UnityEditor.Playables;
 using UnityEngine;
 using UnityEngine.Playables;
 using UnityEngine.UIElements;
@@ -13,7 +12,7 @@ public class PlayableGraphView : UGraphView
     {
         private PlayableGraph _playableGraph;
 
-        private readonly List<PlayableOutputNode> _playableOutputNodes = new List<PlayableOutputNode>();
+        private readonly List<PlayableOutputNode> _rootOutputNodes = new List<PlayableOutputNode>();
 
 
         public PlayableGraphView()
@@ -29,29 +28,37 @@ public PlayableGraph GetPlayableGraph()
             return _playableGraph;
         }
 
-        public void SetPlayableGraph(PlayableGraph playableGraph)
+        public void Update(PlayableGraph playableGraph)
         {
-            //if (IsEqual(ref _playableGraph, ref playableGraph))
-            //{
-            //    return;
-            //}
+            if (!_playableGraph.IsValid())
+            {
+                ClearView();
+            }
 
-            _playableGraph = playableGraph;
+            if (IsEqual(ref _playableGraph, ref playableGraph))
+            {
+                DiffOutputNodes();
+            }
+            else
+            {
+                // playable graph changed
+                _playableGraph = playableGraph;
 
-            ClearView();
+                PopulateView();
+            }
 
-            PopulateView();
+            CalculateLayout();
         }
 
 
         private void ClearView()
         {
-            foreach (var playableOutputNode in _playableOutputNodes)
+            foreach (var playableOutputNode in _rootOutputNodes)
             {
                 playableOutputNode.RemoveFromContainer();
             }
 
-            _playableOutputNodes.Clear();
+            _rootOutputNodes.Clear();
         }
 
         private void PopulateView()
@@ -65,27 +72,85 @@ private void PopulateView()
             for (int i = 0; i < _playableGraph.GetOutputCount(); i++)
             {
                 var playableOutput = _playableGraph.GetOutput(i);
-                var playableOutputTypeName = playableOutput.GetPlayableOutputType().Name;
-                var playableOutputEditorName = playableOutput.GetEditorName();
-                var playableOutputNode = new PlayableOutputNode(0, playableOutput)
+                var playableOutputNode = PlayableOutputNodeFactory.CreateNode(playableOutput);
+                playableOutputNode.AddToContainer(this);
+
+                _rootOutputNodes.Add(playableOutputNode);
+            }
+
+            for (int i = 0; i < _rootOutputNodes.Count; i++)
+            {
+                //_rootOutputNodes[i].CreateAndConnectInputNodes();
+                _rootOutputNodes[i].Update();
+            }
+        }
+
+        private void DiffOutputNodes()
+        {
+            if (!_playableGraph.IsValid())
+            {
+                return;
+            }
+
+            // mark all root nodes inactive
+            for (int i = 0; i < _rootOutputNodes.Count; i++)
+            {
+                _rootOutputNodes[i].RemoveFlag(NodeFlag.Active);
+            }
+
+            // diff nodes
+            for (int i = 0; i < _playableGraph.GetOutputCount(); i++)
+            {
+                var playableOutput = _playableGraph.GetOutput(i);
+                var rootOutputNodeIndex = FindRootOutputNode(playableOutput);
+                if (rootOutputNodeIndex >= 0)
                 {
-                    title = $"{playableOutputTypeName} ({playableOutputEditorName})"
-                };
+                    _rootOutputNodes[i].AddFlag(NodeFlag.Active);
+                    continue;
+                }
+
+                // create new node
+                var playableOutputNode = PlayableOutputNodeFactory.CreateNode(playableOutput);
                 playableOutputNode.AddToContainer(this);
+                playableOutputNode.AddFlag(NodeFlag.Active);
+
+                _rootOutputNodes.Add(playableOutputNode);
+            }
 
-                _playableOutputNodes.Add(playableOutputNode);
+            for (int i = _rootOutputNodes.Count - 1; i >= 0; i--)
+            {
+                var rootOutputNode = _rootOutputNodes[i];
+                if (!rootOutputNode.CheckFlag(NodeFlag.Active))
+                {
+                    rootOutputNode.RemoveFromContainer();
+
+                    _rootOutputNodes.RemoveAt(i);
+                    continue;
+                }
+
+                rootOutputNode.Update();
             }
+        }
 
-            for (int i = 0; i < _playableOutputNodes.Count; i++)
+        private int FindRootOutputNode(PlayableOutput playableOutput)
+        {
+            for (int i = 0; i < _rootOutputNodes.Count; i++)
             {
-                _playableOutputNodes[i].CreateAndConnectInputNodes();
+                if (_rootOutputNodes[i].PlayableOutput.Equals(playableOutput))
+                {
+                    return i;
+                }
             }
 
-            // calculate node layout
+            return -1;
+        }
+
+        private void CalculateLayout()
+        {
             var origin = Vector2.zero;
-            for (int i = 0; i < _playableOutputNodes.Count; i++)
+            for (int i = 0; i < _rootOutputNodes.Count; i++)
             {
-                var outputNode = _playableOutputNodes[i];
+                var outputNode = _rootOutputNodes[i];
                 var treeSize = outputNode.GetHierarchySize();
 
                 outputNode.CalculateLayout(origin);

Editor/Scripts/Node/GraphViewNode.cs

@@ -1,15 +1,35 @@
 using System.Collections.Generic;
 using UnityEditor.Experimental.GraphView;
 using UnityEngine;
+using UEdge = UnityEditor.Experimental.GraphView.Edge;
 using UGraphView = UnityEditor.Experimental.GraphView.GraphView;
 using UNode = UnityEditor.Experimental.GraphView.Node;
 
 namespace GBG.PlayableGraphMonitor.Editor.Node
 {
-    public abstract class GraphViewNode : UNode
+    public enum NodeFlag : uint
+    {
+        None = 0,
+        Active = 1 << 0,
+        Dirty = 1 << 1,
+    }
+
+    public readonly struct NodeInput
     {
-        public int Depth { get; }
+        public UEdge Edge { get; }
 
+        public GraphViewNode Node { get; }
+
+
+        public NodeInput(UEdge edge, GraphViewNode node)
+        {
+            Edge = edge;
+            Node = node;
+        }
+    }
+
+    public abstract class GraphViewNode : UNode
+    {
         public IReadOnlyList<Port> InputPorts => InternalInputPorts;
 
         protected List<Port> InternalInputPorts { get; } = new List<Port>();
@@ -18,30 +38,57 @@ public abstract class GraphViewNode : UNode
 
         protected List<Port> InternalOutputPorts { get; } = new List<Port>();
 
-        // public IReadOnlyList<Edge> InputEdges => InternalInputEdges;
+        protected UGraphView Container { get; set; }
 
-        protected List<Edge> InternalInputEdges { get; } = new List<Edge>();
+        public IReadOnlyList<NodeInput> Inputs => InternalInputs;
 
-        protected UGraphView Container { get; set; }
+        protected List<NodeInput> InternalInputs { get; } = new List<NodeInput>();
 
         protected GraphViewNode Parent { get; private set; }
 
-        protected new List<GraphViewNode> Children { get; } = new List<GraphViewNode>();
 
+        public virtual void Update() { }
 
-        private Vector2? _hierarchySize;
 
+        #region Hierarchy
 
-        protected GraphViewNode(int depth)
+        public virtual void AddToContainer(UGraphView container)
+        {
+            Container = container;
+            Container.AddElement(this);
+        }
+
+        public virtual void RemoveFromContainer()
         {
-            Depth = depth;
+            // self
+            Container.RemoveElement(this);
+
+            // children
+            for (int i = 0; i < InternalInputs.Count; i++)
+            {
+                var input = InternalInputs[i];
+                Container.RemoveElement(input.Edge);
+                input.Node.RemoveFromContainer();
+            }
+
+            InternalInputs.Clear();
+
+            Container = null;
         }
 
+
         protected Port InstantiatePort<TPort>(Direction direction)
         {
             return InstantiatePort(Orientation.Horizontal, direction, Port.Capacity.Single, typeof(TPort));
         }
 
+        #endregion
+
+
+        #region Layout
+
+        private Vector2? _hierarchySize;
+
 
         public Vector2 GetNodeSize()
         {
@@ -56,20 +103,20 @@ public Vector2 GetHierarchySize()
                 return _hierarchySize.Value;
             }
 
-            if (Children.Count == 0)
+            if (Inputs.Count == 0)
             {
                 _hierarchySize = GetNodeSize();
                 return _hierarchySize.Value;
             }
 
             var subHierarchySize = Vector2.zero;
-            for (int i = 0; i < Children.Count; i++)
+            for (int i = 0; i < Inputs.Count; i++)
             {
-                var childSize = Children[i].GetHierarchySize();
+                var childSize = Inputs[i].Node.GetHierarchySize();
                 subHierarchySize.x = Mathf.Max(subHierarchySize.x, childSize.x);
                 subHierarchySize.y += childSize.y;
             }
-            subHierarchySize.y += (Children.Count - 1) * NodeLayoutInfo.VerticalSpace;
+            subHierarchySize.y += (Inputs.Count - 1) * NodeLayoutInfo.VerticalSpace;
 
             var hierarchySize = GetNodeSize() + new Vector2(NodeLayoutInfo.HorizontalSpace, 0);
             hierarchySize.y = Mathf.Max(hierarchySize.y, subHierarchySize.y);
@@ -85,11 +132,11 @@ public void CalculateLayout(Vector2 origin)
             SetPosition(new Rect(nodePos, Vector2.zero));
 
             origin.x -= GetNodeSize().x - NodeLayoutInfo.HorizontalSpace;
-            for (int i = 0; i < Children.Count; i++)
+            for (int i = 0; i < Inputs.Count; i++)
             {
-                var childNode = Children[i];
-                var childHierarchySize = childNode.GetHierarchySize();
-                childNode.CalculateLayout(origin);
+                var childNode = Inputs[i];
+                var childHierarchySize = childNode.Node.GetHierarchySize();
+                childNode.Node.CalculateLayout(origin);
 
                 origin.y += childHierarchySize.y;
             }
@@ -102,36 +149,29 @@ public static Vector2 CalculateSubTreeRootNodePosition(Vector2 subTreeSize, Vect
             return subTreePos;
         }
 
-        public virtual void AddToContainer(UGraphView container)
-        {
-            Container = container;
-            Container.AddElement(this);
-        }
+        #endregion
 
-        public virtual void RemoveFromContainer()
-        {
-            // self
-            Container.RemoveElement(this);
 
-            // input edges
-            for (int i = 0; i < InternalInputEdges.Count; i++)
-            {
-                Container.RemoveElement(InternalInputEdges[i]);
-            }
+        #region Flags
 
-            InternalInputEdges.Clear();
+        private uint _flags = 0;
 
-            // children
-            foreach (var childNode in Children)
-            {
-                childNode.RemoveFromContainer();
-            }
 
-            Children.Clear();
+        public bool CheckFlag(NodeFlag flag)
+        {
+            return (_flags & (uint)flag) != 0;
+        }
 
-            Container = null;
+        public void AddFlag(NodeFlag flag)
+        {
+            _flags |= (uint)flag;
+        }
+
+        public void RemoveFlag(NodeFlag flag)
+        {
+            _flags &= ~(uint)flag;
         }
 
-        public abstract void CreateAndConnectInputNodes();
+        #endregion
     }
 }