Ported GraphVisualizer to new PlayableAPI

- Updated code to reflect new API
- Added support for PlayableOutput

Author: Borealux

Assets/Editor/GraphVisualizer/PlayableGraphVisualizer.cs

@@ -4,25 +4,58 @@
 using GraphVisualizer;
 using UnityEngine.Playables;
 
-public class PlayableGraphNode : Node
+public class SharedPlayableNode : Node
 {
-    public PlayableGraphNode(PlayableHandle content, float weight = 1, bool active = false)
+    public SharedPlayableNode(object content, float weight = 1, bool active = false)
+        : base(content, weight, active)
+    {
+    }
+
+    protected static string InfoString(string key, double value)
+    {
+        return String.Format(
+            ((Math.Abs(value) < 100000.0) ? "<b>{0}:</b> {1:#.###}" : "<b>{0}:</b> {1:E4}"), key, value);
+    }
+
+    protected static string InfoString(string key, int value)
+    {
+        return String.Format("<b>{0}:</b> {1:D}", key, value);
+    }
+
+    protected static string InfoString(string key, object value)
+    {
+        return "<b>" + key + ":</b> " + (value ?? "(none)");
+    }
+
+    protected static string RemoveFromEnd(string str, string suffix)
+    {
+        if (str.EndsWith(suffix))
+        {
+            return str.Substring(0, str.Length - suffix.Length);
+        }
+        return str;
+    }
+}
+
+public class PlayableNode : SharedPlayableNode
+{
+    public PlayableNode(Playable content, float weight = 1, bool active = false)
         : base(content, weight, active)
     {
     }
 
     public override Type GetContentType()
     {
-        IPlayable p = null;
+        Playable p = Playable.Null;
         try
         {
-            p = ((PlayableHandle)content).GetObject<IPlayable>();
+            p = ((Playable)content);
         }
         catch
         {
             // Ignore.
         }
-        return p == null ? null : p.GetType();
+        return !p.IsValid() ? null : p.GetPlayableType();
     }
 
     public override string GetContentTypeShortName()
@@ -39,48 +72,66 @@ public override string ToString()
 
         sb.AppendLine(InfoString("Handle", GetContentTypeShortName()));
 
-        var h = (PlayableHandle)content;
+        var h = (Playable)content;
 
         sb.AppendLine(InfoString("IsValid", h.IsValid()));
 
         if (h.IsValid())
         {
-            sb.AppendLine(InfoString("IsDone", h.isDone));
-            sb.AppendLine(InfoString("InputCount", h.inputCount));
-            sb.AppendLine(InfoString("OutputCount", h.outputCount));
-            sb.AppendLine(InfoString("PlayState", h.playState));
-            sb.AppendLine(InfoString("Speed", h.speed));
-            sb.AppendLine(InfoString("Duration", h.duration));
-            sb.AppendLine(InfoString("Time", h.time));
+            sb.AppendLine(InfoString("IsDone", h.IsDone()));
+            sb.AppendLine(InfoString("InputCount", h.GetInputCount()));
+            sb.AppendLine(InfoString("OutputCount", h.GetOutputCount()));
+            sb.AppendLine(InfoString("PlayState", h.GetPlayState()));
+            sb.AppendLine(InfoString("Speed", h.GetSpeed()));
+            sb.AppendLine(InfoString("Duration", h.GetDuration()));
+            sb.AppendLine(InfoString("Time", h.GetTime()));
             //        sb.AppendLine(InfoString("Animation", h.animatedProperties));
         }
 
         return sb.ToString();
     }
+}
 
-    private static string InfoString(string key, double value)
+public class PlayableOutputNode : SharedPlayableNode
+{
+    public PlayableOutputNode(PlayableOutput content)
+        : base(content, content.GetWeight(), true)
     {
-        return String.Format(
-            ((Math.Abs(value) < 100000.0) ? "<b>{0}:</b> {1:#.###}" : "<b>{0}:</b> {1:E4}") , key, value);
     }
 
-    private static string InfoString(string key, int value)
+    public override Type GetContentType()
     {
-        return String.Format("<b>{0}:</b> {1:D}", key, value);
+        PlayableOutput p = PlayableOutput.Null;
+        try
+        {
+            p = ((PlayableOutput)content);
+        }
+        catch
+        {
+            // Ignore.
+        }
+        return !p.IsOutputValid() ? null : p.GetPlayableOutputType();
     }
 
-    private static string InfoString(string key, object value)
+    public override string GetContentTypeShortName()
     {
-        return "<b>" + key + ":</b> " + (value ?? "(none)");
+        // Remove the extra Playable at the end of the Playable types.
+        string shortName = base.GetContentTypeShortName();
+        string cleanName = RemoveFromEnd(shortName, "PlayableOutput") + "Output";
+        return string.IsNullOrEmpty(cleanName) ? shortName : cleanName;
     }
 
-    private static string RemoveFromEnd(string str, string suffix)
+    public override string ToString()
     {
-        if (str.EndsWith(suffix))
-        {
-            return str.Substring(0, str.Length - suffix.Length);
-        }
-        return str;
+        var sb = new StringBuilder();
+
+        sb.AppendLine(InfoString("Handle", GetContentTypeShortName()));
+
+        var h = (PlayableOutput)content;
+
+        sb.AppendLine(InfoString("IsValid", h.IsOutputValid()));
+
+        return sb.ToString();
     }
 }
 
@@ -95,47 +146,81 @@ public PlayableGraphVisualizer(PlayableGraph playableGraph)
 
     protected override void Populate()
     {
-        if (!m_PlayableGraph.IsValid()) return;
-        int roots = m_PlayableGraph.rootPlayableCount;
-        for (int i = 0; i < roots; i++)
+        if (!m_PlayableGraph.IsValid())
+            return;
+
+        int outputs = m_PlayableGraph.GetOutputCount();
+        for (int i = 0; i < outputs; i++)
         {
-            AddNodeHierarchy(CreateNodeFromPlayableHandle(m_PlayableGraph.GetRootPlayable(i), 1.0f));
+            var output = m_PlayableGraph.GetOutput(i);
+            if(output.IsOutputValid())
+            {
+                AddNodeHierarchy(CreateNodeFromPlayableOutput(output));
+            }
         }
     }
 
     protected override IEnumerable<Node> GetChildren(Node node)
     {
-        // Children are the PlayableHandle Inputs.
-        return GetInputsNode((PlayableHandle)node.content);
+        // Children are the Playable Inputs.
+        if(node is PlayableNode)
+            return GetInputsFromPlayableNode((Playable)node.content);
+        else if(node is PlayableOutputNode)
+            return GetInputsFromPlayableOutputNode((PlayableOutput)node.content);
+
+        return new List<Node>();     
     }
 
-    private List<Node> GetInputsNode(PlayableHandle h)
+    private List<Node> GetInputsFromPlayableNode(Playable h)
     {
         var inputs = new List<Node>();
-        for (int port = 0; port < h.inputCount; ++port)
+        if (h.IsValid())
         {
-            PlayableHandle playableHandle = h.GetInput(port);
-            if (playableHandle.IsValid())
+            for (int port = 0; port < h.GetInputCount(); ++port)
+            {
+                Playable playable = h.GetInput(port);
+                if (playable.IsValid())
+                {
+                    float weight = h.GetInputWeight(port);
+                    Node node = CreateNodeFromPlayable(playable, weight);
+                    inputs.Add(node);
+                }
+            }
+        }
+        return inputs;
+    }
+
+    private List<Node> GetInputsFromPlayableOutputNode(PlayableOutput h)
+    {
+        var inputs = new List<Node>();
+        if (h.IsOutputValid())
+        {            
+            Playable playable = h.GetSourcePlayable();
+            if (playable.IsValid())
             {
-                float weight = h.GetInputWeight(port);
-                Node node = CreateNodeFromPlayableHandle(playableHandle, weight);
+                Node node = CreateNodeFromPlayable(playable, 1);
                 inputs.Add(node);
             }
         }
         return inputs;
     }
 
-    private PlayableGraphNode CreateNodeFromPlayableHandle(PlayableHandle h, float weight)
+    private PlayableNode CreateNodeFromPlayable(Playable h, float weight)
+    {
+        return new PlayableNode(h, weight, h.GetPlayState() == PlayState.Playing);
+    }
+
+    private PlayableOutputNode CreateNodeFromPlayableOutput(PlayableOutput h)
     {
-        return new PlayableGraphNode(h, weight, h.playState == PlayState.Playing);
+        return new PlayableOutputNode(h);
     }
 
-    private static bool HasValidOuputs(PlayableHandle h)
+    private static bool HasValidOuputs(Playable h)
     {
-        for (int port = 0; port < h.outputCount; ++port)
+        for (int port = 0; port < h.GetOutputCount(); ++port)
         {
-            PlayableHandle playableHandle = h.GetOutput(port);
-            if (playableHandle.IsValid())
+            Playable playable = h.GetOutput(port);
+            if (playable.IsValid())
             {
                 return true;
             }

Assets/Editor/GraphVisualizer/PlayableGraphVisualizerWindow.cs

@@ -100,7 +100,6 @@ void OnGUI()
         // that are in the current scene.
         if (m_AutoScanScene)
         {
-#if PLAYABLE_DIRECTOR
             // This code could be generalized, maybe if we added a IHasPlayableGraph Interface.
             IList<PlayableDirector> directors = FindObjectsOfType<PlayableDirector>();
             if (directors != null)
@@ -115,8 +114,7 @@ void OnGUI()
                     }
                 }
             }
-#endif
-#if ANIMATOR_5_6
+
             IList<Animator> animators = FindObjectsOfType<Animator>();
             if (animators != null)
             {
@@ -130,7 +128,6 @@ void OnGUI()
                     }
                 }
             }
-#endif
         }
 
         if (GraphVisualizerClient.GetGraphs() != null)