Changed the code to make it work with version 5.6.0b5

Author: Borealux

Assets/Clients/GraphVisualizerClient.cs

@@ -0,0 +1,45 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine.Experimental.Director;
+
+// Bridge between runtime and editor code: the graph created in runtime code can call GraphVisualizerClient.Show(...)
+// and the EditorWindow will register itself with the client to display any available graph.
+public class GraphVisualizerClient
+{
+    private static GraphVisualizerClient s_Instance;
+    private Dictionary<PlayableGraph, string> m_Graphs = new Dictionary<PlayableGraph, string>();
+
+    public static GraphVisualizerClient instance
+    {
+        get
+        {
+            if (s_Instance == null)
+                s_Instance = new GraphVisualizerClient();
+            return s_Instance;
+        }
+    }
+    ~GraphVisualizerClient()
+    {
+        m_Graphs.Clear();
+    }
+    public static void Show(PlayableGraph graph, string name)
+    {
+        if (!instance.m_Graphs.ContainsKey(graph))
+        {
+            instance.m_Graphs.Add(graph, name);
+        }
+    }
+    public static void Hide(PlayableGraph graph)
+    {
+        if (instance.m_Graphs.ContainsKey(graph))
+        {
+            instance.m_Graphs.Remove(graph);
+        }
+    }
+
+    public static IEnumerable<KeyValuePair<PlayableGraph, string>> GetGraphs()
+    {
+        return instance.m_Graphs;
+    }
+}

Assets/Clients/GraphVisualizerClient.cs.meta

@@ -66,5 +66,10 @@ IEnumerator IEnumerable.GetEnumerator()
         {
             return m_Nodes.GetEnumerator();
         }
+
+        public bool IsEmpty()
+        {
+            return m_Nodes.Count == 0;
+        }
     }
 }

Assets/Editor/GraphVisualizer/Graph.meta

@@ -97,13 +97,13 @@ private float[] ComputeHorizontalPositionForEachLevel()
             nodes.Add(node);
             maxDepth = Mathf.Max(d, maxDepth);
         }
-            
+
         // Bake the left to right horizontal positions.
         var horizontalPositionForDepth = new float[maxDepth];
         horizontalPositionForDepth[0] = 0;
         for (int d = 1; d < maxDepth; ++d)
         {
-            IEnumerable<Node> nodesOnThisLevel = nodeDepths[d+1];
+            IEnumerable<Node> nodesOnThisLevel = nodeDepths[d + 1];
 
             int maxChildren = nodesOnThisLevel.Max(x => x.children.Count);
 

Assets/Editor/GraphVisualizer/Graph/Graph.cs

@@ -5,8 +5,7 @@
 using System.Linq;
 using System.Text.RegularExpressions;
 using GraphVisualizer;
-using UnityEngine.Timeline;
-using UnityEngine.Playables;
+using UnityEngine.Experimental.Director;
 
 public class DefaultGraphRenderer : IGraphRenderer
 {
@@ -51,26 +50,33 @@ public DefaultGraphRenderer()
 
     public void Draw(IGraphLayout graphLayout, Rect drawingArea)
     {
-        NodeConstraints defaults;
+        GraphSettings defaults;
         defaults.maximumNormalizedNodeSize = s_DefaultMaximumNormalizedNodeSize;
         defaults.maximumNodeSizeInPixels = s_DefaultMaximumNodeSizeInPixels;
         defaults.aspectRatio = s_DefaultAspectRatio;
+        defaults.showLegend = true;
         Draw(graphLayout, drawingArea, defaults);
     }
 
-    public void Draw(IGraphLayout graphLayout, Rect totalDrawingArea, NodeConstraints nodeConstraints)
+    public void Draw(IGraphLayout graphLayout, Rect totalDrawingArea, GraphSettings graphSettings)
     {
-        PrepareLegend(graphLayout.vertices);
+        var legendArea = new Rect();
+        var drawingArea = new Rect(totalDrawingArea);
 
-        var legendArea = new Rect(totalDrawingArea)
+        if (graphSettings.showLegend)
         {
-            width = EstimateLegendWidth() + s_BorderSize * 2
-        };
+            PrepareLegend(graphLayout.vertices);
 
-        var drawingArea = new Rect(totalDrawingArea);
+            legendArea = new Rect(totalDrawingArea)
+            {
+                width = EstimateLegendWidth() + s_BorderSize * 2
+            };
 
-        legendArea.x = drawingArea.xMax - legendArea.width;
-        drawingArea.width -= legendArea.width;// + s_BorderSize;
+            legendArea.x = drawingArea.xMax - legendArea.width;
+            drawingArea.width -= legendArea.width;// + s_BorderSize;
+
+            DrawLegend(legendArea);
+        }
 
         if (m_SelectedNode != null)
         {
@@ -85,8 +91,7 @@ public void Draw(IGraphLayout graphLayout, Rect totalDrawingArea, NodeConstraint
             }
         }
 
-        DrawGraph(graphLayout, drawingArea, nodeConstraints);
-        DrawLegend(legendArea);
+        DrawGraph(graphLayout, drawingArea, graphSettings);
     }
 
     private void InitializeStyles()
@@ -132,6 +137,9 @@ private void PrepareLegend(IEnumerable<Vertex> vertices)
         m_LegendForType.Clear();
         foreach (Vertex v in vertices)
         {
+            if (v.node == null)
+                continue;
+
             string nodeType = v.node.GetContentTypeName();
 
             if (m_LegendForType.ContainsKey(nodeType))
@@ -199,7 +207,7 @@ private void DrawLegend(Rect legendArea)
         GUILayout.BeginVertical();
 
         GUILayout.Label("Inspector", m_SubTitleStyle);
-        
+
         if (m_SelectedNode != null)
         {
             GUILayout.Label(m_SelectedNode.ToString(), m_InspectorStyle);
@@ -277,7 +285,7 @@ private void DrawEdgeWeightColorBar(float width)
     }
 
     // Draw the graph and returns the selected Node if there's any.
-    private void DrawGraph(IGraphLayout graphLayout, Rect drawingArea, NodeConstraints nodeConstraints)
+    private void DrawGraph(IGraphLayout graphLayout, Rect drawingArea, GraphSettings graphSettings)
     {
         // add border, except on right-hand side where the legend will provide necessary padding
         drawingArea = new Rect(drawingArea.x + s_BorderSize,
@@ -292,12 +300,12 @@ private void DrawGraph(IGraphLayout graphLayout, Rect drawingArea, NodeConstrain
         }
 
         // Increase b by maximum node size (since b is measured between node centers)
-        b.Expand(new Vector3(nodeConstraints.maximumNormalizedNodeSize, nodeConstraints.maximumNormalizedNodeSize, 0));
+        b.Expand(new Vector3(graphSettings.maximumNormalizedNodeSize, graphSettings.maximumNormalizedNodeSize, 0));
 
         var scale = new Vector2(drawingArea.width / b.size.x, drawingArea.height / b.size.y);
         var offset = new Vector2(-b.min.x, -b.min.y);
 
-        Vector2 nodeSize = ComputeNodeSize(scale, nodeConstraints);
+        Vector2 nodeSize = ComputeNodeSize(scale, graphSettings);
 
         GUI.BeginGroup(drawingArea);
 
@@ -364,35 +372,35 @@ private void DrawGraph(IGraphLayout graphLayout, Rect drawingArea, NodeConstrain
     }
 
     // Apply node constraints to node size
-    private static Vector2 ComputeNodeSize(Vector2 scale, NodeConstraints nodeConstraints)
+    private static Vector2 ComputeNodeSize(Vector2 scale, GraphSettings graphSettings)
     {
         var extraTickness = (s_SelectedNodeThickness + s_ActiveNodeThickness) * 2.0f;
-        var nodeSize = new Vector2(nodeConstraints.maximumNormalizedNodeSize * scale.x - extraTickness,
-            nodeConstraints.maximumNormalizedNodeSize * scale.y - extraTickness);
+        var nodeSize = new Vector2(graphSettings.maximumNormalizedNodeSize * scale.x - extraTickness,
+            graphSettings.maximumNormalizedNodeSize * scale.y - extraTickness);
 
         // Adjust aspect ratio after scaling
         float currentAspectRatio = nodeSize.x / nodeSize.y;
 
-        if (currentAspectRatio > nodeConstraints.aspectRatio)
+        if (currentAspectRatio > graphSettings.aspectRatio)
         {
             // Shrink x dimension
-            nodeSize.x = nodeSize.y * nodeConstraints.aspectRatio;
+            nodeSize.x = nodeSize.y * graphSettings.aspectRatio;
         }
         else
         {
             // Shrink y dimension
-            nodeSize.y = nodeSize.x / nodeConstraints.aspectRatio;
+            nodeSize.y = nodeSize.x / graphSettings.aspectRatio;
         }
 
         // If node size is still too big, scale down
-        if (nodeSize.x > nodeConstraints.maximumNodeSizeInPixels)
+        if (nodeSize.x > graphSettings.maximumNodeSizeInPixels)
         {
-            nodeSize *= nodeConstraints.maximumNodeSizeInPixels / nodeSize.x;
+            nodeSize *= graphSettings.maximumNodeSizeInPixels / nodeSize.x;
         }
 
-        if (nodeSize.y > nodeConstraints.maximumNodeSizeInPixels)
+        if (nodeSize.y > graphSettings.maximumNodeSizeInPixels)
         {
-            nodeSize *= nodeConstraints.maximumNodeSizeInPixels / nodeSize.y;
+            nodeSize *= graphSettings.maximumNodeSizeInPixels / nodeSize.y;
         }
         return nodeSize;
     }

Assets/Editor/GraphVisualizer/Graph/Graph.cs.meta

@@ -6,11 +6,13 @@ namespace GraphVisualizer
     public interface IGraphRenderer
     {
         void Draw(IGraphLayout graphLayout, Rect drawingArea);
-        void Draw(IGraphLayout graphLayout, Rect drawingArea, NodeConstraints nodeConstraints);
+        void Draw(IGraphLayout graphLayout, Rect drawingArea, GraphSettings graphSettings);
     }
 
-    // Customization of how the graph nodes should be rendered (size, distances and proportions)
-    public struct NodeConstraints
+    // Customization of how the graph will be displayed:
+    // - size, distances and proportions of nodes
+    // - legend
+    public struct GraphSettings
     {
         // In layout units. If 1, node will be drawn as large as possible to avoid overlapping, and to respect aspect ratio
         public float maximumNormalizedNodeSize;
@@ -20,5 +22,8 @@ public struct NodeConstraints
 
         // width / height; 1 represents a square node
         public float aspectRatio;
+
+        // Control the display of the legend.
+        public bool showLegend;
     }
 }