[Shader Graph]Tidy function input nodes to now handle input dimensions nicely.

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Testing/UnitTests/SerializedGraphTests.cs

 using System;
+using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
 using UnityEngine;
             graph.RemoveNode(graph.GetNodes<INode>().FirstOrDefault());
             Assert.AreEqual(0, graph.GetNodes<INode>().Count());
         }
+        
+        [Test]
+        public void TestCanModifyNodeDrawState()
+        {
+            var node = new SerializableNode();
+            node.name = "Test Node";
+
+            var drawState = node.drawState;
+            var newPos = new Rect(10,10,10,10);
+            drawState.position = newPos;
+            drawState.expanded = false;
+            node.drawState = drawState;
+
+            Assert.AreEqual(drawState, node.drawState);
+            Assert.AreEqual(newPos, node.drawState.position);
+            Assert.IsFalse(node.drawState.expanded);
+        }
+
+        private class SetErrorNode : SerializableNode
+        {
+            public void SetError()
+            {
+                hasError = true;
+            }
+            public void ClearError()
+            {
+                hasError = false;
+            }
+        }
+
+        [Test]
+        public void TestChildClassCanModifyErrorState()
+        {
+            var node = new SetErrorNode();
+            node.SetError();
+            Assert.IsTrue(node.hasError);
+            node.ClearError();
+            Assert.IsFalse(node.hasError);
+        }
+
+        [Test]
+        public void TestNodeGUIDCanBeRewritten()
+        {
+            var node = new SerializableNode();
+            var guid = node.guid;
+            var newGuid = node.RewriteGuid();
+            Assert.AreNotEqual(guid, newGuid);
+        }
 
         [Test]
         public void TestRemoveNodeFromSerializableGraphCleansEdges()
             Assert.AreEqual(1, graph.GetNodes<INode>().Count());
         }
 
+        private class OnEnableNode : SerializableNode, IOnAssetEnabled
+        {
+            public bool called = false;
+            public void OnEnable()
+            {
+                called = true;
+            }
+        }
+
+        [Test]
+        public void TestSerializedGraphDelegatesOnEnableCalls()
+        {
+            var graph = new SerializableGraph();
+            var node = new OnEnableNode();
+            node.name = "Test Node";
+            graph.AddNode(node);
+            
+            Assert.IsFalse(node.called);
+            graph.OnEnable();
+            Assert.IsTrue(node.called);
+        }
+
         [Test]
         public void TestCanFindNodeInSerializableGraph()
         {
             Assert.AreEqual(1, found.GetOutputSlots<ISlot>().Count());
             Assert.AreEqual("output", found.GetOutputSlots<ISlot>().FirstOrDefault().name);
             Assert.AreEqual(2, found.GetSlots<ISlot>().Count());
+        }
+
+        [Test]
+        public void TestCanNotAddNullSlotToSerializableNode()
+        {
+            var node = new SerializableNode();
+            node.AddSlot(null);
+            node.name = "Test Node";
+            Assert.AreEqual(0, node.GetOutputSlots<ISlot>().Count());
         }
 
         [Test]
         }
 
         [Test]
-        public void TestCanUpdatePriorityByReaddingSlotToSerializableNode()
+        public void TestCanUpdateSlotPriority()
+        {
+            var graph = new SerializableGraph();
+            var node = new SerializableNode();
+            node.AddSlot(new SerializableSlot("output", "output", SlotType.Output, 0));
+            node.name = "Test Node";
+            graph.AddNode(node);
+
+            Assert.AreEqual(1, graph.GetNodes<INode>().Count());
+            var found = graph.GetNodes<INode>().FirstOrDefault();
+            Assert.AreEqual(0, found.GetInputSlots<ISlot>().Count());
+            Assert.AreEqual(1, found.GetOutputSlots<ISlot>().Count());
+            Assert.AreEqual(1, found.GetSlots<ISlot>().Count());
+
+            var slot = found.GetOutputSlots<ISlot>().FirstOrDefault();
+            Assert.AreEqual(0, slot.priority);
+            slot.priority = 2;
+            Assert.AreEqual(2, slot.priority);
+        }
+
+        [Test]
+        public void TestCanUpdateSlotPriorityByReaddingSlotToSerializableNode()
         {
             var graph = new SerializableGraph();
             var node = new SerializableNode();
 
             var slot = found.GetOutputSlots<ISlot>().FirstOrDefault();
             Assert.AreEqual(1, slot.priority);
+        }
+
+
+        [Test]
+        public void TestCanUpdateSlotDisplayName()
+        {
+            var node = new SerializableNode();
+            node.AddSlot(new SerializableSlot("output", "output", SlotType.Output, 0));
+            node.name = "Test Node";
+            
+            Assert.AreEqual(0, node.GetInputSlots<ISlot>().Count());
+            Assert.AreEqual(1, node.GetOutputSlots<ISlot>().Count());
+            Assert.AreEqual(1, node.GetSlots<ISlot>().Count());
+
+            var slot = node.GetOutputSlots<ISlot>().FirstOrDefault();
+            Assert.IsNotNull(slot);
+            Assert.AreEqual("output", slot.displayName);
+            slot.displayName = "test";
+            Assert.AreEqual("test", slot.displayName);
         }
 
         [Test]
             var foundInputSlot = foundInputNode.FindInputSlot<ISlot>(edge.inputSlot.slotName);
             Assert.AreEqual(inputNode, foundInputNode);
             Assert.AreEqual(inputSlot, foundInputSlot);
+        }
+
+        [Test]
+        public void TestCanConnectAndTraverseThreeNodesOnSerializableGraph()
+        {
+            var graph = new SerializableGraph();
+            var outputNode = new SerializableNode();
+            var outputNodeOutputSlot = new SerializableSlot("output", "output", SlotType.Output, 0);
+            outputNode.AddSlot(outputNodeOutputSlot);
+            graph.AddNode(outputNode);
+
+            var middleNode = new SerializableNode();
+            var middleNodeInputSlot = new SerializableSlot("input", "input", SlotType.Input, 0);
+            var middleNodeoutputSlot = new SerializableSlot("output", "output", SlotType.Output, 0);
+            middleNode.AddSlot(middleNodeInputSlot);
+            middleNode.AddSlot(middleNodeoutputSlot);
+            graph.AddNode(middleNode);
+
+            var inputNode = new SerializableNode();
+            var inputNodeInputSlot1 = new SerializableSlot("input1", "input1", SlotType.Input, 0);
+            var inputNodeInputSlot2 = new SerializableSlot("input2", "input2", SlotType.Input, 1);
+            inputNode.AddSlot(inputNodeInputSlot1);
+            inputNode.AddSlot(inputNodeInputSlot2);
+            graph.AddNode(inputNode);
+            
+            Assert.AreEqual(3, graph.GetNodes<INode>().Count());
+
+            graph.Connect(outputNode.GetSlotReference("output"), middleNode.GetSlotReference("input"));
+            Assert.AreEqual(1, graph.edges.Count());
+
+            graph.Connect(middleNode.GetSlotReference("output"), inputNode.GetSlotReference("input1"));
+            Assert.AreEqual(2, graph.edges.Count());
+            
+            var edgesOnMiddleNode = NodeUtils.GetAllEdges(middleNode);
+            Assert.AreEqual(2, edgesOnMiddleNode.Count());
+
+            List<INode> result = new List<INode>();
+            NodeUtils.DepthFirstCollectNodesFromNode(result, inputNode);
+            Assert.AreEqual(3, result.Count);
+
+            result.Clear();
+            NodeUtils.DepthFirstCollectNodesFromNode(result, inputNode, inputNodeInputSlot1);
+            Assert.AreEqual(3, result.Count);
+
+            result.Clear();
+            NodeUtils.DepthFirstCollectNodesFromNode(result, inputNode, inputNodeInputSlot2);
+            Assert.AreEqual(1, result.Count);
+
+            result.Clear();
+            NodeUtils.DepthFirstCollectNodesFromNode(result, inputNode, inputNodeInputSlot1, false);
+            Assert.AreEqual(2, result.Count);
+
+            result.Clear();
+            NodeUtils.DepthFirstCollectNodesFromNode(result, inputNode, inputNodeInputSlot2, false);
+            Assert.AreEqual(0, result.Count);
+            
+            result.Clear();
+            NodeUtils.DepthFirstCollectNodesFromNode(result, null);
+            Assert.AreEqual(0, result.Count);
+        }
+
+        [Test]
+        public void TestConectionToSameInputReplacesOldInput()
+        {
+            var graph = new SerializableGraph();
+            var outputNode = new SerializableNode();
+            var outputSlot1 = new SerializableSlot("output1", "output1", SlotType.Output, 0);
+            var outputSlot2 = new SerializableSlot("output2", "output2", SlotType.Output, 1);
+            outputNode.AddSlot(outputSlot1);
+            outputNode.AddSlot(outputSlot2);
+            graph.AddNode(outputNode);
+
+            var inputNode = new SerializableNode();
+            var inputSlot = new SerializableSlot("input", "input", SlotType.Input, 0);
+            inputNode.AddSlot(inputSlot);
+            graph.AddNode(inputNode);
+
+            Assert.AreEqual(2, graph.GetNodes<INode>().Count());
+
+            var createdEdge = graph.Connect(outputNode.GetSlotReference("output1"), inputNode.GetSlotReference("input"));
+            Assert.AreEqual(1, graph.edges.Count());
+            var edge = graph.edges.FirstOrDefault();
+            Assert.AreEqual(createdEdge, edge);
+
+            var createdEdge2 = graph.Connect(outputNode.GetSlotReference("output2"), inputNode.GetSlotReference("input"));
+            Assert.AreEqual(1, graph.edges.Count());
+            var edge2 = graph.edges.FirstOrDefault();
+            Assert.AreEqual(createdEdge2, edge2);
+        }
+
+        [Test]
+        public void TestRemovingSlotRemovesConnectedEdges()
+        {
+            var graph = new SerializableGraph();
+            var outputNode = new SerializableNode();
+            var outputSlot = new SerializableSlot("output", "output", SlotType.Output, 0);
+            outputNode.AddSlot(outputSlot);
+            graph.AddNode(outputNode);
+
+            var inputNode = new SerializableNode();
+            var inputSlot = new SerializableSlot("input", "input", SlotType.Input, 0);
+            inputNode.AddSlot(inputSlot);
+            graph.AddNode(inputNode);
+
+            Assert.AreEqual(2, graph.GetNodes<INode>().Count());
+
+            graph.Connect(outputNode.GetSlotReference("output"), inputNode.GetSlotReference("input"));
+            Assert.AreEqual(1, graph.edges.Count());
+           
+            inputNode.RemoveSlot("input");
+            Assert.AreEqual(0, graph.edges.Count());
+        }
+
+        [Test]
+        public void TestCanNotConnectToNullSlot()
+        {
+            var graph = new SerializableGraph();
+            var outputNode = new SerializableNode();
+            var outputSlot = new SerializableSlot("output", "output", SlotType.Output, 0);
+            outputNode.AddSlot(outputSlot);
+            graph.AddNode(outputNode);
+
+            var inputNode = new SerializableNode();
+            graph.AddNode(inputNode);
+
+            Assert.AreEqual(2, graph.GetNodes<INode>().Count());
+
+            var createdEdge = graph.Connect(outputNode.GetSlotReference("output"), null);
+            Assert.AreEqual(0, graph.edges.Count());
+            Assert.IsNull(createdEdge);
+
+            var createdEdge2 = graph.Connect(outputNode.GetSlotReference("output"), new SlotReference(Guid.NewGuid(), "nope"));
+            Assert.AreEqual(0, graph.edges.Count());
+            Assert.IsNull(createdEdge2);
         }
 
         [Test]

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Runtime/Implementation/NodeUtils.cs

 
 namespace UnityEngine.Graphing
 {
-    public class NodeUtils
+    public static class NodeUtils
     {
         public static IEnumerable<IEdge> GetAllEdges(INode node)
         {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/UnitTests/MaterialNodeTests.cs.meta

 fileFormatVersion: 2
 guid: 8f553306b9101064eb1010e15de5f567
-timeCreated: 1466414003
+timeCreated: 1469179824
 licenseType: Pro
 MonoImporter:
   serializedVersion: 2

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/AbsoluteNode.cs

-using UnityEngine.Graphing;
-
-    class AbsoluteNode : Function1Input, IGeneratesFunction
+    class AbsoluteNode : Function1Input
     {
         public AbsoluteNode()
         {
-        protected override string GetFunctionName() {return "unity_absolute_" + precision; }
-
-        public void GenerateNodeFunction(ShaderGenerator visitor, GenerationMode generationMode)
-        {
-            var outputString = new ShaderGenerator();
-            
-            outputString.AddShaderChunk("inline " + precision + outputDimension + " unity_absolute_" + precision + " (" + precision + outputDimension + " arg1)", false);
-            outputString.AddShaderChunk("{", false);
-            outputString.Indent();
-            outputString.AddShaderChunk("return abs(arg1);", false);
-            outputString.Deindent();
-            outputString.AddShaderChunk("}", false);
-
-            visitor.AddShaderChunk(outputString.GetShaderString(0), true);
-        }
+        protected override string GetFunctionName() {return "abs"; }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/AddNode.cs

         public void GenerateNodeFunction(ShaderGenerator visitor, GenerationMode generationMode)
         {
             var outputString = new ShaderGenerator();
-            outputString.AddShaderChunk("inline " + precision + outputDimension + " unity_add_" + precision + " (" + precision + outputDimension +" arg1, " + precision + outputDimension + " arg2)", false);
+            outputString.AddShaderChunk(GetFunctionPrototype("arg1", "arg2"), false);
             outputString.AddShaderChunk("{", false);
             outputString.Indent();
             outputString.AddShaderChunk("return arg1 + arg2;", false);

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/BlendNode.cs

         }
 
         protected override string GetFunctionName() { return "unity_blend_" + kOpNames[(int)m_Operation] + "_" + precision; }
+
         protected override string GetFunctionCallBody(string input1Value, string input2Value)
         {
             return GetFunctionName() + "(" + input1Value + ", " + input2Value + ", " + m_Blend + ")";

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/ClampNode.cs

-using UnityEngine.Graphing;
-
-    public class ClampNode : Function3Input, IGeneratesFunction
+    public class ClampNode : Function3Input
     {
         public ClampNode()
         {
-        protected override string GetFunctionName() {return "unity_clamp_" + precision; }
-
-        public void GenerateNodeFunction(ShaderGenerator visitor, GenerationMode generationMode)
-        {
-            var outputString = new ShaderGenerator();
-            outputString.AddShaderChunk("inline " + precision + "4 unity_clamp_" + precision + " (" + precision + "4 arg1, " + precision + "4 minval, " + precision + "4 maxval)", false);
-            outputString.AddShaderChunk("{", false);
-            outputString.Indent();
-            outputString.AddShaderChunk("return clamp(arg1, minval, maxval);", false);
-            outputString.Deindent();
-            outputString.AddShaderChunk("}", false);
-            visitor.AddShaderChunk(outputString.GetShaderString(0), true);
-        }
-
+        protected override string GetFunctionName() {return "clamp"; }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/DivNode.cs

         public void GenerateNodeFunction(ShaderGenerator visitor, GenerationMode generationMode)
         {
             var outputString = new ShaderGenerator();
-            outputString.AddShaderChunk("inline " + precision + "4 unity_div_" + precision + " (" + precision + "4 arg1, " + precision + "4 arg2)", false);
+            outputString.AddShaderChunk(GetFunctionPrototype("arg1", "arg2"), false);
             outputString.AddShaderChunk("{", false);
             outputString.Indent();
             outputString.AddShaderChunk("return arg1 / arg2;", false);

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/FresnelNode.cs

         {
             name = "FresnelNode";
         }
-        
+
+        protected override MaterialSlot GetInputSlot1()
+        {
+            return new MaterialSlot(GetInputSlot1Name(), GetInputSlot1Name(), SlotType.Input, 0, SlotValueType.Vector3, Vector4.zero);
+        }
+
+        protected override MaterialSlot GetInputSlot2()
+        {
+            return new MaterialSlot(GetInputSlot2Name(), GetInputSlot2Name(), SlotType.Input, 1, SlotValueType.Vector3, Vector4.zero);
+        }
+
+        protected override MaterialSlot GetOutputSlot()
+        {
+            return new MaterialSlot(GetOutputSlotName(), GetOutputSlotName(), SlotType.Output, 0, SlotValueType.Vector1, Vector4.zero);
+        }
+
-            
-            outputString.AddShaderChunk("inline " + precision + "4 unity_fresnel_" + precision + " (" + precision + "4 arg1, " + precision + "4 arg2)", false);
+            outputString.AddShaderChunk(GetFunctionPrototype("arg1", "arg2"), false);
-            outputString.AddShaderChunk("return (1.0 - dot (normalize (arg1.xyz), normalize (arg2.xyz))).xxxx;", false);
+            outputString.AddShaderChunk("return (1.0 - dot (normalize (arg1), normalize (arg2)));", false);
             outputString.Deindent();
             outputString.AddShaderChunk("}", false);
 

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/Function1Input.cs

         protected virtual string GetOutputSlotName() {return "Output"; }
 
         protected abstract string GetFunctionName();
+        
+        protected virtual string GetFunctionPrototype(string argName)
+        {
+            return "inline " + precision + outputDimension + " " + GetFunctionName() + " ("
+                + precision + inputDimension + " " + argName + ")";
+        }
 
         public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
         {

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/Function2Input.cs

             get { return ConvertConcreteSlotValueTypeToString(FindOutputSlot<MaterialSlot>(GetOutputSlotName()).concreteValueType); }
         }
 
-        public string input1Dimension
+        private string input1Dimension
-        public string input2Dimension
+        private string input2Dimension
         {
             get { return ConvertConcreteSlotValueTypeToString(FindInputSlot<MaterialSlot>(GetInputSlot2Name()).concreteValueType); }
         }

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/Function3Input.cs

         {
             AddSlot(GetInputSlot1());
             AddSlot(GetInputSlot2());
+            AddSlot(GetInputSlot3());
             AddSlot(GetOutputSlot());
             RemoveSlotsNameNotMatching(validSlots);
         }
         protected virtual string GetFunctionCallBody(string inputValue1, string inputValue2, string inputValue3)
         {
             return GetFunctionName() + " (" + inputValue1 + ", " + inputValue2 + ", " + inputValue3 + ")";
-        }
-
-                protected virtual string GetFunctionCallBody(string inputValue)
-        {
-            return GetFunctionName() + " (" + inputValue + ")";
         }
 
         public string outputDimension

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/LerpNode.cs

 namespace UnityEngine.MaterialGraph
 {
     [Title("Math/Lerp Node")]
-    public class LerpNode : Function3Input, IGeneratesFunction
+    public class LerpNode : Function3Input
     {
         public LerpNode()
         {
-        protected override string GetFunctionName() {return "unity_lerp_" + precision; }
-
-        public void GenerateNodeFunction(ShaderGenerator visitor, GenerationMode generationMode)
-        {
-            var outputString = new ShaderGenerator();
-            outputString.AddShaderChunk(GetFunctionPrototype("first", "second", "s"), false);
-            outputString.AddShaderChunk("{", false);
-            outputString.Indent();
-            outputString.AddShaderChunk("return lerp(first, second, s);", false);
-            outputString.Deindent();
-            outputString.AddShaderChunk("}", false);
-
-            visitor.AddShaderChunk(outputString.GetShaderString(0), true);
-        }
+        protected override string GetFunctionName() {return "lerp"; }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/MaxNode.cs

-using UnityEngine.Graphing;
-
 namespace UnityEngine.MaterialGraph
 {
     [Title("Math/Maximum Node")]

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/MultiplyNode.cs

         public void GenerateNodeFunction(ShaderGenerator visitor, GenerationMode generationMode)
         {
             var outputString = new ShaderGenerator();
-            outputString.AddShaderChunk("inline " + precision + outputDimension + " " + GetFunctionName() + " (" + precision + input1Dimension + " arg1, " + precision + input2Dimension + " arg2)", false);
+            outputString.AddShaderChunk(GetFunctionPrototype("arg1", "arg2"), false);
             outputString.AddShaderChunk("{", false);
             outputString.Indent();
             outputString.AddShaderChunk("return arg1 * arg2;", false);

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/QuantizeNode.cs

         public void GenerateNodeFunction(ShaderGenerator visitor, GenerationMode generationMode)
         {
             var outputString = new ShaderGenerator();
-            outputString.AddShaderChunk("inline " + precision + "4 unity_quantize_" + precision + " (" + precision + "4 input, " + precision + "4 stepsize)", false);
+            outputString.AddShaderChunk(GetFunctionPrototype("input", "stepsize"), false);
             outputString.AddShaderChunk("{", false);
             outputString.Indent();
             outputString.AddShaderChunk("return floor(input / stepsize) * stepsize;", false);

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/ReflectNode.cs

         protected override string GetInputSlot2Name() {return "Direction"; }
         protected override string GetOutputSlotName() {return "Reflection"; }
 
+        protected override MaterialSlot GetInputSlot1()
+        {
+            return new MaterialSlot(GetInputSlot1Name(), GetInputSlot1Name(), SlotType.Input, 0, SlotValueType.Vector3, Vector4.zero);
+        }
+
+        protected override MaterialSlot GetInputSlot2()
+        {
+            return new MaterialSlot(GetInputSlot2Name(), GetInputSlot2Name(), SlotType.Input, 1, SlotValueType.Vector3, Vector4.zero);
+        }
+
+        protected override MaterialSlot GetOutputSlot()
+        {
+            return new MaterialSlot(GetOutputSlotName(), GetOutputSlotName(), SlotType.Output, 0, SlotValueType.Vector3, Vector4.zero);
+        }
+
-            outputString.AddShaderChunk("inline " + precision + "4 unity_reflect_" + precision + " (" + precision + "4 normal, " + precision + "4 direction)", false);
+            outputString.AddShaderChunk(GetFunctionPrototype("normal", "direction"), false);
-            outputString.AddShaderChunk(precision + "3 vn = normalize(normal.xyz);", false);
-            outputString.AddShaderChunk(precision + "3 vd = normalize(direction.xyz);", false);
-            outputString.AddShaderChunk("return half4 (2 * dot(vn, vd) * vn - vd, 1.0);", false);
+            outputString.AddShaderChunk(precision + "3 vn = normalize(normal);", false);
+            outputString.AddShaderChunk(precision + "3 vd = normalize(direction);", false);
+            outputString.AddShaderChunk("return 2 * dot(vn, vd) * vn - vd, 1.0;", false);
             outputString.Deindent();
             outputString.AddShaderChunk("}", false);
 

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/SmoothStepNode.cs

 namespace UnityEngine.MaterialGraph
 {
     [Title("Math/SmoothStep Node")]
-    class SmoothStepNode : Function3Input, IGeneratesFunction
+    class SmoothStepNode : Function3Input
     {
         public SmoothStepNode()
         {
-        protected override string GetFunctionName() {return "unity_smoothstep_" + precision; }
-
-        public void GenerateNodeFunction(ShaderGenerator visitor, GenerationMode generationMode)
-        {
-            var outputString = new ShaderGenerator();
-            outputString.AddShaderChunk("inline " + precision + "4 unity_smoothstep_" + precision + " (" + precision + "4 input, " + precision + "4 edge1, " + precision + "4 edge2)", false);
-            outputString.AddShaderChunk("{", false);
-            outputString.Indent();
-            outputString.AddShaderChunk("return smoothstep(edge1, edge2, input);", false);
-            outputString.Deindent();
-            outputString.AddShaderChunk("}", false);
+        protected override string GetFunctionName() {return "smoothstep"; }
-            visitor.AddShaderChunk(outputString.GetShaderString(0), true);
-        }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/UnpackNormalNode.cs

-using System;
 using UnityEngine.Graphing;
 
 
         {
             get { return false; }
         }
-        
+
+        protected virtual MaterialSlot GetInputSlot()
+        {
+            return new MaterialSlot(GetInputSlotName(), GetInputSlotName(), SlotType.Input, 0, SlotValueType.Vector4, Vector4.zero);
+        }
+
+        protected virtual MaterialSlot GetOutputSlot()
+        {
+            return new MaterialSlot(GetOutputSlotName(), GetOutputSlotName(), SlotType.Output, 0, SlotValueType.Vector3, Vector4.zero);
+        }
+
         protected override string GetInputSlotName() {return "PackedNormal"; }
         protected override string GetOutputSlotName() {return "Normal"; }
 
-        }
-
-        protected override string GetFunctionCallBody(string inputValue)
-        {
-            return precision + "4(" + GetFunctionName() + " (" + inputValue + ")" + ", 0)";
         }
     }
 }