Merge branch 'dev'

Author: SolarianZ

Documents.meta

@@ -1,5 +1,7 @@
 using GBG.PlayableGraphMonitor.Editor.Node;
+using GBG.PlayableGraphMonitor.Editor.Utility;
 using System.Collections.Generic;
+using UnityEditor;
 using UnityEditor.Experimental.GraphView;
 using UnityEngine;
 using UnityEngine.Playables;
@@ -23,31 +25,29 @@ public PlayableGraphView()
             SetupZoom(ContentZoomer.DefaultMinScale, ContentZoomer.DefaultMaxScale);
         }
 
-        public PlayableGraph GetPlayableGraph()
-        {
-            return _playableGraph;
-        }
-
         public void Update(PlayableGraph playableGraph)
         {
+            var needFrameAll = !GraphTool.IsEqual(ref _playableGraph, ref playableGraph);
+
+            _playableGraph = playableGraph;
+
             if (!_playableGraph.IsValid())
             {
                 ClearView();
             }
 
-            if (IsEqual(ref _playableGraph, ref playableGraph))
-            {
-                DiffOutputNodes();
-            }
-            else
-            {
-                // playable graph changed
-                _playableGraph = playableGraph;
-
-                PopulateView();
-            }
+            PopulateView();
 
             CalculateLayout();
+
+            if (needFrameAll)
+            {
+                // wait for view initialize at least 2 frames
+                EditorApplication.delayCall += () =>
+                {
+                    EditorApplication.delayCall += () => { FrameAll(); };
+                };
+            }
         }
 
 
@@ -68,30 +68,6 @@ private void PopulateView()
                 return;
             }
 
-            // create nodes
-            for (int i = 0; i < _playableGraph.GetOutputCount(); i++)
-            {
-                var playableOutput = _playableGraph.GetOutput(i);
-                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++)
             {
@@ -158,24 +134,5 @@ private void CalculateLayout()
                 origin.y += treeSize.y + NodeLayoutInfo.VerticalSpace;
             }
         }
-
-
-        private static bool IsEqual(ref PlayableGraph a, ref PlayableGraph b)
-        {
-            if (!a.IsValid())
-            {
-                return !b.IsValid();
-            }
-
-            if (!b.IsValid())
-            {
-                return false;
-            }
-
-            var nameA = a.GetEditorName();
-            var nameB = b.GetEditorName();
-
-            return nameA.Equals(nameB);
-        }
     }
 }

Documents/imgs.meta

@@ -16,15 +16,23 @@ public enum NodeFlag : uint
 
     public readonly struct NodeInput
     {
-        public UEdge Edge { get; }
+        public readonly UEdge Edge;
 
-        public GraphViewNode Node { get; }
+        public readonly GraphViewNode Node;
 
+        public readonly int PortIndex;
 
-        public NodeInput(UEdge edge, GraphViewNode node)
+
+        public NodeInput(UEdge edge, GraphViewNode node, int portIndex)
         {
             Edge = edge;
             Node = node;
+            PortIndex = portIndex;
+        }
+
+        public NodeInput Copy(NodeInput other, int portIndexOverride)
+        {
+            return new NodeInput(other.Edge, other.Node, portIndexOverride);
         }
     }
 

Documents/imgs/img_sample_playablegraph_monitor.png

@@ -1,6 +1,6 @@
-using System;
+using GBG.PlayableGraphMonitor.Editor.Utility;
+using System;
 using UnityEditor.Experimental.GraphView;
-using UnityEngine;
 using UnityEngine.Playables;
 
 namespace GBG.PlayableGraphMonitor.Editor.Node
@@ -27,6 +27,7 @@ public override void Update()
 
             if (!Playable.IsValid())
             {
+                style.backgroundColor = GraphTool.GetNodeInvalidColor();
                 return;
             }
 
@@ -36,8 +37,13 @@ public override void Update()
                 InternalInputs[i].Node.RemoveFlag(NodeFlag.Active);
             }
 
+            // diff child nodes
             for (int i = 0; i < Playable.GetInputCount(); i++)
             {
+                // update self port color
+                var inputWeight = Playable.GetInputWeight(i);
+                InternalInputPorts[i].portColor = GraphTool.GetPortColor(inputWeight);
+
                 var inputPlayable = Playable.GetInput(i);
                 if (!inputPlayable.IsValid())
                 {
@@ -47,7 +53,9 @@ public override void Update()
                 var childNodeIndex = FindChildPlayableNode(inputPlayable);
                 if (childNodeIndex >= 0)
                 {
-                    InternalInputs[i].Node.AddFlag(NodeFlag.Active);
+                    var input = InternalInputs[i];
+                    input.Node.AddFlag(NodeFlag.Active);
+                    InternalInputs[i] = input.Copy(input, i);
                     continue;
                 }
 
@@ -60,12 +68,15 @@ public override void Update()
                 var selfInputPort = InternalInputPorts[i];
                 var edge = selfInputPort.ConnectTo(inputPlayableNodeOutputPort);
                 Container.AddElement(edge);
-                InternalInputs.Add(new NodeInput(edge, inputPlayableNode));
+                InternalInputs.Add(new NodeInput(edge, inputPlayableNode, i));
             }
 
+            // update child nodes
             for (int i = InternalInputs.Count - 1; i >= 0; i--)
             {
                 var input = InternalInputs[i];
+
+                // remove inactive child node
                 if (!input.Node.CheckFlag(NodeFlag.Active))
                 {
                     Container.RemoveElement(input.Edge);
@@ -75,6 +86,11 @@ public override void Update()
                     continue;
                 }
 
+                // update child port color
+                var inputWeight = Playable.GetInputWeight(input.PortIndex);
+                input.Node.OutputPorts[0].portColor = GraphTool.GetPortColor(inputWeight);
+                input.Edge.UpdateEdgeControl();
+
                 InternalInputs[i].Node.Update();
             }
         }
@@ -105,7 +121,7 @@ private void CreatePorts()
             {
                 var inputPort = InstantiatePort<Playable>(Direction.Input);
                 inputPort.portName = $"Input {i}";
-                inputPort.portColor = Color.white;
+                inputPort.portColor = GraphTool.GetPortColor(Playable.GetInputWeight(i));
                 inputContainer.Add(inputPort);
                 InternalInputPorts.Add(inputPort);
             }
@@ -114,7 +130,7 @@ private void CreatePorts()
             {
                 var outputPort = InstantiatePort<Playable>(Direction.Output);
                 outputPort.portName = $"Output {i}";
-                outputPort.portColor = Color.white;
+                outputPort.portColor = GraphTool.GetPortColor(1);
                 outputContainer.Add(outputPort);
                 InternalOutputPorts.Add(outputPort);
             }

Documents/imgs/img_sample_playablegraph_monitor.png.meta

@@ -1,18 +1,28 @@
-using UnityEngine.Animations;
+using GBG.PlayableGraphMonitor.Editor.Utility;
+using UnityEngine.Animations;
 using UnityEngine.Playables;
 
 namespace GBG.PlayableGraphMonitor.Editor.Node
 {
     public static class PlayableNodeFactory
     {
+        public const string PlayableHeader = "Playable";
+
         public static PlayableNode CreateNode(Playable playable)
         {
             var playableType = playable.GetPlayableType();
             var playableTypeName = playableType.Name;
+            var playableTypeSortName = playableTypeName
+                .Remove(playableTypeName.Length - PlayableHeader.Length);
+            var nodeTitle = $"{PlayableHeader}\n{playableTypeSortName}";
+
+            PlayableNode playableNode;
+
+            // todo create node by playable type
 
             if (playableType == typeof(AnimationClipPlayable))
             {
-
+                //goto SET_NODE_TITLE;
             }
 
             if (playableType == typeof(AnimationMixerPlayable))
@@ -28,11 +38,13 @@ public static PlayableNode CreateNode(Playable playable)
             // ...
 
             // default node
-            var playableNode = new PlayableNode(playable)
-            {
-                title = playableTypeName
-            };
+            playableNode = new PlayableNode(playable);
+
+        SET_NODE_TITLE:
+            playableNode.title = nodeTitle;
+            playableNode.SetNodeStyle(playable.GetPlayableNodeColor());
+
             return playableNode;
         }
     }
-}
+}