feat: bug fix & sorting code

Author: SolarianZ

Editor/Scripts/GraphView/GraphViewNode.cs

@@ -1,9 +1,8 @@
 using System.Collections.Generic;
-using System.Linq;
+using GBG.PlayableGraphMonitor.Editor.Node;
 using UnityEditor.Experimental.GraphView;
 using UnityEditor.Playables;
 using UnityEngine;
-using UnityEngine.Assertions;
 using UnityEngine.Playables;
 using UnityEngine.UIElements;
 using UGraphView = UnityEditor.Experimental.GraphView.GraphView;
@@ -39,13 +38,26 @@ public void SetPlayableGraph(PlayableGraph playableGraph, bool forceRepaint)
 
             _playableGraph = playableGraph;
 
-            for (int i = 0; i < _playableOutputNodes.Count; i++)
+            ClearView();
+
+            PopulateView();
+
+            // FrameAll();
+        }
+
+
+        private void ClearView()
+        {
+            foreach (var playableOutputNode in _playableOutputNodes)
             {
-                RemoveElement(_playableOutputNodes[i]);
+                playableOutputNode.RemoveFromContainer();
             }
 
             _playableOutputNodes.Clear();
+        }
 
+        private void PopulateView()
+        {
             if (!_playableGraph.IsValid())
             {
                 return;
@@ -56,16 +68,20 @@ public void SetPlayableGraph(PlayableGraph playableGraph, bool forceRepaint)
                 var playableOutput = _playableGraph.GetOutput(i);
                 var playableOutputTypeName = playableOutput.GetPlayableOutputType().Name;
                 var playableOutputEditorName = playableOutput.GetEditorName();
-                var playableOutputNode = new PlayableOutputNode(this, 0, playableOutput)
+                var playableOutputNode = new PlayableOutputNode(0, playableOutput)
                 {
                     title = $"{playableOutputTypeName} ({playableOutputEditorName})"
                 };
                 playableOutputNode.SetPosition(new Rect(200, 200, 0, 0));
+                playableOutputNode.AddToContainer(this);
+
                 _playableOutputNodes.Add(playableOutputNode);
-                AddElement(playableOutputNode);
             }
 
-            FrameAll();
+            for (int i = 0; i < _playableOutputNodes.Count; i++)
+            {
+                _playableOutputNodes[i].CreateAndConnectInputNodes();
+            }
         }
 
 

Editor/Scripts/GraphView/GraphViewNode.cs.meta

@@ -0,0 +1,74 @@
+using System.Collections.Generic;
+using GBG.PlayableGraphMonitor.Editor.GraphView;
+using UnityEditor.Experimental.GraphView;
+using UnityEngine.Assertions;
+using UGraphView = UnityEditor.Experimental.GraphView.GraphView;
+using UNode = UnityEditor.Experimental.GraphView.Node;
+
+namespace GBG.PlayableGraphMonitor.Editor.Node
+{
+    public abstract class GraphViewNode : UNode
+    {
+        public int Depth { get; }
+
+        public IReadOnlyList<Port> InputPorts => InternalInputPorts;
+
+        protected List<Port> InternalInputPorts { get; } = new List<Port>();
+
+        public IReadOnlyList<Port> OutputPorts => InternalOutputPorts;
+
+        protected List<Port> InternalOutputPorts { get; } = new List<Port>();
+
+        protected UGraphView Container { get;  set; }
+
+        // public IReadOnlyList<Edge> InputEdges => InternalInputEdges;
+
+        protected List<Edge> InternalInputEdges { get; } = new List<Edge>();
+
+        protected List<GraphViewNode> ChildNodes { get; } = new List<GraphViewNode>();
+
+
+        public virtual void AddToContainer(UGraphView container)
+        {
+            Container = container;
+            Container.AddElement(this);
+        }
+
+        public virtual void RemoveFromContainer()
+        {
+            // self
+            Container.RemoveElement(this);
+
+            // input edges
+            for (int i = 0; i < InternalInputEdges.Count; i++)
+            {
+                Container.RemoveElement(InternalInputEdges[i]);
+            }
+
+            InternalInputEdges.Clear();
+
+            // children
+            foreach (var childNode in ChildNodes)
+            {
+                childNode.RemoveFromContainer();
+            }
+
+            ChildNodes.Clear();
+
+            Container = null;
+        }
+
+        public abstract void CreateAndConnectInputNodes();
+
+
+        protected GraphViewNode(int depth)
+        {
+            Depth = depth;
+        }
+
+        protected Port InstantiatePort<TPort>(Direction direction)
+        {
+            return InstantiatePort(Orientation.Horizontal, direction, Port.Capacity.Single, typeof(TPort));
+        }
+    }
+}

Editor/Scripts/GraphView/PlayableGraphView.cs

@@ -2,72 +2,79 @@
 using UnityEngine;
 using UnityEngine.Playables;
 
-namespace GBG.PlayableGraphMonitor.Editor.GraphView
+namespace GBG.PlayableGraphMonitor.Editor.Node
 {
     public class PlayableNode : GraphViewNode
     {
         public Playable Playable { get; }
 
-        public PlayableNode(PlayableGraphView owner, int depth, Playable playable)
-            : base(owner, depth)
+        public PlayableNode(int depth, Playable playable)
+            : base(depth)
         {
             Playable = playable;
 
             CreatePorts();
             RefreshExpandedState();
             RefreshPorts();
-
-            CreateAndConnectInputNodes();
         }
 
-
-        private void CreatePorts()
+        public override void CreateAndConnectInputNodes()
         {
             if (!Playable.IsValid())
             {
                 return;
             }
 
+            var inputPlayableDepth = Depth + 1;
             for (int i = 0; i < Playable.GetInputCount(); i++)
             {
-                var inputPort = InstantiatePort<Playable>(Direction.Input);
-                inputPort.portColor = Color.white;
-                inputContainer.Add(inputPort);
-                InternalInputPorts.Add(inputPort);
+                var inputPlayable = Playable.GetInput(i);
+                var inputPlayableTypeName = inputPlayable.GetPlayableType().Name;
+                var inputPlayableNode = new PlayableNode(inputPlayableDepth, inputPlayable)
+                {
+                    title = inputPlayableTypeName
+                };
+                inputPlayableNode.SetPosition(new Rect(-400 * inputPlayableDepth, 200, 0, 0));
+                inputPlayableNode.AddToContainer(Container);
+                ChildNodes.Add(inputPlayableNode);
+
+                var inputPlayableNodeOutputPort = inputPlayableNode.OutputPorts[0];
+                var selfInputPort = InternalInputPorts[i];
+                var edge = selfInputPort.ConnectTo(inputPlayableNodeOutputPort);
+                Container.AddElement(edge);
+                InternalInputEdges.Add(edge);
             }
 
-            for (int i = 0; i < Playable.GetOutputCount(); i++)
+            for (int i = 0; i < ChildNodes.Count; i++)
             {
-                var outputPort = InstantiatePort<Playable>(Direction.Output);
-                outputPort.portColor = Color.white;
-                outputContainer.Add(outputPort);
-                InternalOutputPorts.Add(outputPort);
+                ChildNodes[i].CreateAndConnectInputNodes();
             }
         }
 
-        private void CreateAndConnectInputNodes()
+
+        private void CreatePorts()
         {
             if (!Playable.IsValid())
             {
                 return;
             }
 
-            var inputPlayableDepth = Depth + 1;
             for (int i = 0; i < Playable.GetInputCount(); i++)
             {
-                var inputPlayable = Playable.GetInput(i);
-                var inputPlayableTypeName = inputPlayable.GetPlayableType().Name;
-                var inputPlayableNode = new PlayableNode(Owner, inputPlayableDepth, inputPlayable)
-                {
-                    title = inputPlayableTypeName
-                };
-                inputPlayableNode.SetPosition(new Rect(-400 * inputPlayableDepth, 200, 0, 0));
-                Owner.AddElement(inputPlayableNode);
+                var inputPort = InstantiatePort<Playable>(Direction.Input);
+                inputPort.portName = $"Input {i}";
+                inputPort.portColor = Color.white;
+                inputContainer.Add(inputPort);
+                InternalInputPorts.Add(inputPort);
+            }
 
-                var inputPlayableOutputPortIndex = 0;
-                var inputPlayableOutputPort = InternalInputPorts[inputPlayableOutputPortIndex];
-                var edge = inputPlayableOutputPort.ConnectTo(inputPlayableNode.OutputPorts[0]);
-                Owner.AddElement(edge);
+            for (int i = 0; i < Playable.GetOutputCount(); i++)
+            {
+                var outputPort = InstantiatePort<Playable>(Direction.Output);
+                outputPort.portName = $"Output {i}";
+                outputPort.portColor = Color.white;
+                outputContainer.Add(outputPort);
+                InternalOutputPorts.Add(outputPort);
             }
         }
     }