simplify evaluating port dimensions on start

Author: z3y

Editor/Generation/ShaderBuilder.cs

@@ -5,9 +5,7 @@
 using UnityEditor.Experimental.GraphView;
 using UnityEngine;
 using Graphlit.Nodes.PortType;
-using System.Linq.Expressions;
 using System;
-using static UnityEditor.Rendering.CameraUI;
 
 namespace Graphlit
 {
@@ -306,45 +304,54 @@ public static void GenerateUnifiedPreview(ShaderGraphView graphView, ShaderNode
             }
         }
 
-        public static void GenerateAllPreviews(ShaderGraphView graphView)
+        static void EvaluateDimensionsRecursive(HashSet<string> visitedNodes, ShaderNode node)
         {
-            graphView.UpdateCachedNodesForBuilder();
-            var nodes = graphView.cachedNodesForBuilder;
+            if (visitedNodes.Contains(node.viewDataKey))
+            {
+                return;
+            }
 
-            foreach (var shaderNode in nodes)
+            foreach (var input in node.Inputs)
             {
-                bool skip = false;
-                foreach (var input in shaderNode.Inputs)
-                {
-                    if (input.connected)
-                    {
-                        skip = true;
-                        continue;
-                    }
-                }
-                if (skip)
+                foreach (var edge in input.connections)
                 {
-                    continue;
+                    EvaluateDimensionsRecursive(visitedNodes, (ShaderNode)edge.output.node);
+                    break;
                 }
+            }
 
-                var rightNodesAdded = new HashSet<string>();
-                var rightNodes = new List<ShaderNode>();
+            node.EvaluateDimensionsForGraphView();
+            visitedNodes.Add(node.viewDataKey);
+        }
 
-                foreach (var output in shaderNode.Outputs)
+        public static void GenerateAllPreviews(ShaderGraphView graphView)
+        {
+            graphView.UpdateCachedNodesForBuilder();
+            var nodes = graphView.cachedNodesForBuilder;
+
+            var endNodes = new List<ShaderNode>();
+            foreach (var node in nodes)
+            {
+                bool include = true;
+                foreach (var output in node.Outputs)
                 {
-                    foreach (var edge in output.connections)
+                    if (output.connected)
                     {
-                        GetConnectedNodesFromEdgeRight(rightNodes, edge, rightNodesAdded);
+                        include = false;
                     }
                 }
-                shaderNode.EvaluateDimensionsForGraphView();
-
-                foreach (var rightNode in rightNodes)
+                if (include)
                 {
-                    rightNode.EvaluateDimensionsForGraphView();
+                    endNodes.Add(node);
                 }
             }
 
+            var visitedNodes = new HashSet<string>();
+            foreach (var node in endNodes)
+            {
+                EvaluateDimensionsRecursive(visitedNodes, node);
+            }
+
             var generatedNodes = new HashSet<string>();
 
             foreach (var node in nodes)
@@ -358,7 +365,6 @@ public static void GenerateAllPreviews(ShaderGraphView graphView)
                     generatedNodes.Add(node.viewDataKey);
                 }
             }
-
         }
 
         public static void GeneratePreviewFromEdge(ShaderGraphView graphView, Edge edge, bool toRemove)

Editor/Serialization/SerializableGraph.cs

@@ -66,19 +66,20 @@ public void PopulateGraph(ShaderGraphView graphView)
             var sw = new System.Diagnostics.Stopwatch();
             sw.Start();
 
-            // try catch node connections arent lost
-            try
+            
+            foreach (var node in nodes)
             {
-                foreach (var node in nodes)
+                try
                 {
                     graphView.AddNode(node);
                 }
-                //Debug.Log("Add Nodes: " + sw.ElapsedMilliseconds);
-            }
-            catch (Exception e)
-            {
-                Debug.LogError(e);
+                catch (Exception e)
+                {
+                    Debug.LogError(e);
+                }
             }
+            //Debug.Log("Add Nodes: " + sw.ElapsedMilliseconds);
+            
             sw.Restart();
             SetupNodeConnections(graphView);
             //Debug.Log("Setup Connections: " + sw.ElapsedMilliseconds);

Editor/ShaderGraphView.cs

@@ -27,7 +27,7 @@ public class ShaderGraphView : GraphView
 
         public void UpdateCachedNodesForBuilder()
         {
-            cachedNodesForBuilder = graphElements.OfType<ShaderNode>().ToList();
+            cachedNodesForBuilder = nodes.OfType<ShaderNode>().ToList();
             cachedRegisterVariablesForBuilder = cachedNodesForBuilder.OfType<RegisterVariableNode>().ToList();
             //Debug.Log($"UpdateCachedNodesForBuilder");
         }

Editor/ShaderNode/Nodes/Standard Library/SwizzleNode.cs

@@ -25,15 +25,15 @@ public override void Initialize()
                 if (!swizzle.Equals(newValue))
                 {
                     swizzle = newValue;
-                    EvaluateDimensionsForGraphView();
-                    SetPortColor(outport, Float.GetPortColor(evaluatedOutputDimensions[OUT]));
+                    //EvaluateDimensionsForGraphView();
+                    SetPortColor(outport, Float.GetPortColor(swizzle.Length));
                     GeneratePreviewForAffectedNodes();
                 }
             });
             extensionContainer.Add(f);
 
-            EvaluateDimensionsForGraphView();
-            SetPortColor(outport, Float.GetPortColor(evaluatedOutputDimensions[OUT]));
+            //EvaluateDimensionsForGraphView();
+            SetPortColor(outport, Float.GetPortColor(swizzle.Length));
         }
 
         protected override void Generate(NodeVisitor visitor)

Editor/ShaderNode/ShaderNode.cs

@@ -357,11 +357,6 @@ internal set
         public Dictionary<int, int> evaluatedOutputDimensions = new Dictionary<int, int>();
         public void EvaluateDimensionsForGraphView()
         {
-            if (this is FetchVariableNode)
-            {
-                return;
-            }
-
             var inputDimensions = new Dictionary<int, int>();
 
             foreach (var port in Inputs)
@@ -449,9 +444,19 @@ public void EvaluateDimensionsForGraphView()
                 return;
             }
 
+            if (this is FetchVariableNode fv)
+            {
+                var registers = GraphView.cachedRegisterVariablesForBuilder.Where(x => x._name == fv._name);
+                foreach (var regs in registers)
+                {
+                    regs.evaluatedOutputDimensions[1] = trunc;
+                    SetPortColor(regs.inputContainer.Children().OfType<Port>().First(), Float.GetPortColor(trunc));
+                }
+            }
             if (this is RegisterVariableNode reg)
             {
                 var fetches = GraphView.cachedNodesForBuilder.OfType<FetchVariableNode>().Where(x => x._name == reg._name);
+                //Debug.Log(trunc);
                 foreach (var fetch in fetches)
                 {
                     fetch.evaluatedOutputDimensions[1] = trunc;
@@ -598,7 +603,7 @@ void AddStyles()
         }
         public TextElement TitleLabel;
 
-        float _lastClickTime = 0;
+        //float _lastClickTime = 0;
 
         public string GetTitleTooltip() => GetType().Name + "\n" + viewDataKey;
         void AddTitleElement()