Merge branch 'master' into node-settings

com.unity.shadergraph/Editor/Data/Graphs/ColorMaterialSlot.cs

             Vector4 value,
             ShaderStage shaderStage = ShaderStage.Dynamic,
             bool hidden = false)
-            : base(slotId, displayName, shaderOutputName, slotType, value, shaderStage, hidden)
+            : base(slotId, displayName, shaderOutputName, slotType, value, shaderStage, hidden: hidden)
         {
         }
 

com.unity.shadergraph/Editor/Data/Graphs/ColorRGBMaterialSlot.cs

             Color value,
             ShaderStage shaderStage = ShaderStage.Dynamic,
             bool hidden = false)
-            : base(slotId, displayName, shaderOutputName, slotType, (Vector4)value, shaderStage, hidden)
+            : base(slotId, displayName, shaderOutputName, slotType, (Vector4)value, shaderStage, hidden: hidden)
         {
         }
 

com.unity.shadergraph/Editor/Data/Graphs/DynamicValueMaterialSlot.cs

 using System;
+using System.Linq;
 using UnityEditor.Graphing;
 using UnityEditor.ShaderGraph.Drawing.Slots;
 using UnityEngine;
 
 		[SerializeField]
 		private Matrix4x4 m_DefaultValue;
+
+	    static readonly string[] k_Labels = {"X", "Y", "Z", "W"};
 
 		private ConcreteSlotValueType m_ConcreteValueType = ConcreteSlotValueType.Vector4;
 
 
 		public override VisualElement InstantiateControl()
 		{
-			int components =
-				concreteValueType == ConcreteSlotValueType.Vector4 ? 4 :
-				concreteValueType == ConcreteSlotValueType.Vector3 ? 3 :
-				concreteValueType == ConcreteSlotValueType.Vector2 ? 2 :
-				concreteValueType == ConcreteSlotValueType.Vector1 ? 1 : 0;
-			
-			return new MultiFloatSlotControlView(owner, components, () => value.GetRow(0), (newValue) => value = new Matrix4x4(newValue, value.GetRow(1), value.GetRow(2), value.GetRow(3)));
+		    var labels = k_Labels.Take(concreteValueType.GetChannelCount()).ToArray();
+			return new MultiFloatSlotControlView(owner, labels, () => value.GetRow(0), (newValue) => value = new Matrix4x4(newValue, value.GetRow(1), value.GetRow(2), value.GetRow(3)));
 		}
 
 		public override SlotValueType valueType { get { return SlotValueType.Dynamic; } }

com.unity.shadergraph/Editor/Data/Graphs/DynamicVectorMaterialSlot.cs

 using System;
+using System.Linq;
 using UnityEditor.Graphing;
 using UnityEditor.ShaderGraph.Drawing.Slots;
 using UnityEngine;
 
         [SerializeField]
         private Vector4 m_DefaultValue;
+
+        static readonly string[] k_Labels = {"X", "Y", "Z", "W"};
 
         private ConcreteSlotValueType m_ConcreteValueType = ConcreteSlotValueType.Vector4;
 
 
         public override VisualElement InstantiateControl()
         {
-            int components =
-                concreteValueType == ConcreteSlotValueType.Vector4 ? 4 :
-                concreteValueType == ConcreteSlotValueType.Vector3 ? 3 :
-                concreteValueType == ConcreteSlotValueType.Vector2 ? 2 :
-                concreteValueType == ConcreteSlotValueType.Vector1 ? 1 : 0;
-            return new MultiFloatSlotControlView(owner, components, () => value, (newValue) => value = newValue);
+            var labels = k_Labels.Take(concreteValueType.GetChannelCount()).ToArray();
+            return new MultiFloatSlotControlView(owner, labels, () => value, (newValue) => value = newValue);
         }
 
         public override SlotValueType valueType { get { return SlotValueType.DynamicVector; } }

com.unity.shadergraph/Editor/Data/Graphs/MaterialSlot.cs

                 case SlotValueType.DynamicVector:
                     return new DynamicVectorMaterialSlot(slotId, displayName, shaderOutputName, slotType, defaultValue, shaderStage, hidden);
                 case SlotValueType.Vector4:
-                    return new Vector4MaterialSlot(slotId, displayName, shaderOutputName, slotType, defaultValue, shaderStage, hidden);
+                    return new Vector4MaterialSlot(slotId, displayName, shaderOutputName, slotType, defaultValue, shaderStage, hidden: hidden);
-                    return new Vector3MaterialSlot(slotId, displayName, shaderOutputName, slotType, defaultValue, shaderStage, hidden);
+                    return new Vector3MaterialSlot(slotId, displayName, shaderOutputName, slotType, defaultValue, shaderStage, hidden: hidden);
-                    return new Vector2MaterialSlot(slotId, displayName, shaderOutputName, slotType, defaultValue, shaderStage, hidden);
+                    return new Vector2MaterialSlot(slotId, displayName, shaderOutputName, slotType, defaultValue, shaderStage, hidden: hidden);
-                    return new Vector1MaterialSlot(slotId, displayName, shaderOutputName, slotType, defaultValue.x, shaderStage, hidden);
+                    return new Vector1MaterialSlot(slotId, displayName, shaderOutputName, slotType, defaultValue.x, shaderStage, hidden: hidden);
                 case SlotValueType.Dynamic:
                     return new DynamicValueMaterialSlot(slotId, displayName, shaderOutputName, slotType, new Matrix4x4(defaultValue, Vector4.zero, Vector4.zero, Vector4.zero), shaderStage, hidden);
                 case SlotValueType.Boolean:

com.unity.shadergraph/Editor/Data/Graphs/ScreenPositionMaterialSlot.cs

 
         public ScreenPositionMaterialSlot(int slotId, string displayName, string shaderOutputName, ScreenSpaceType screenSpaceType,
                                           ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
-            : base(slotId, displayName, shaderOutputName, SlotType.Input, Vector3.zero, shaderStage, hidden)
+            : base(slotId, displayName, shaderOutputName, SlotType.Input, Vector3.zero, shaderStage, hidden: hidden)
         {
             this.screenSpaceType = screenSpaceType;
         }

com.unity.shadergraph/Editor/Data/Graphs/SpaceMaterialSlot.cs

 
         protected SpaceMaterialSlot(int slotId, string displayName, string shaderOutputName, CoordinateSpace space,
                                     ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
-            : base(slotId, displayName, shaderOutputName, SlotType.Input, Vector3.zero, shaderStage, hidden)
+            : base(slotId, displayName, shaderOutputName, SlotType.Input, Vector3.zero, shaderStage, hidden: hidden)
         {
             this.space = space;
         }

com.unity.shadergraph/Editor/Data/Graphs/UVMaterialSlot.cs

 
         public UVMaterialSlot(int slotId, string displayName, string shaderOutputName, UVChannel channel,
                               ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
-            : base(slotId, displayName, shaderOutputName, SlotType.Input, Vector2.zero, shaderStage, hidden)
+            : base(slotId, displayName, shaderOutputName, SlotType.Input, Vector2.zero, shaderStage, hidden: hidden)
         {
             this.channel = channel;
         }

com.unity.shadergraph/Editor/Data/Graphs/Vector1MaterialSlot.cs

     public class Vector1MaterialSlot : MaterialSlot, IMaterialSlotHasValue<float>
     {
         [SerializeField]
-        private float m_Value;
+        float m_Value;
-        private float m_DefaultValue;
+        float m_DefaultValue;
+
+        string[] m_Labels;
 
         public Vector1MaterialSlot()
         {}
             SlotType slotType,
             float value,
             ShaderStage shaderStage = ShaderStage.Dynamic,
+            string label1 = "X",
+            m_Labels = new[] { label1 };
         }
 
         public float defaultValue { get { return m_DefaultValue; } }
 
         public override VisualElement InstantiateControl()
         {
-            return new MultiFloatSlotControlView(owner, 1, () => new Vector4(value, 0f, 0f, 0f), (newValue) => value = newValue.x);
+            return new MultiFloatSlotControlView(owner, m_Labels, () => new Vector4(value, 0f, 0f, 0f), (newValue) => value = newValue.x);
         }
 
         protected override string ConcreteSlotValueAsVariable(AbstractMaterialNode.OutputPrecision precision)

com.unity.shadergraph/Editor/Data/Graphs/Vector1ShaderProperty.cs

                 case FloatType.Integer:
                     return new IntegerNode { value = (int)value };
                 default:
-                    return new Vector1Node { value = value };
+                    var node = new Vector1Node();
+                    node.FindInputSlot<Vector1MaterialSlot>(Vector1Node.InputSlotXId).value = value;
+                    return node;
             }
         }
     }

com.unity.shadergraph/Editor/Data/Graphs/Vector2MaterialSlot.cs

     public class Vector2MaterialSlot : MaterialSlot, IMaterialSlotHasValue<Vector2>
     {
         [SerializeField]
-        private Vector2 m_Value;
+        Vector2 m_Value;
-        private Vector2 m_DefaultValue;
+        Vector2 m_DefaultValue;
+
+        string[] m_Labels;
 
         public Vector2MaterialSlot()
         {}
             SlotType slotType,
             Vector2 value,
             ShaderStage shaderStage = ShaderStage.Dynamic,
+            string label1 = "X",
+            string label2 = "Y",
+            m_Labels = new[] { label1, label2 };
         }
 
         public Vector2 defaultValue { get { return m_DefaultValue; } }
 
         public override VisualElement InstantiateControl()
         {
-            return new MultiFloatSlotControlView(owner, 2, () => value, (newValue) => value = newValue);
+            return new MultiFloatSlotControlView(owner, m_Labels, () => value, (newValue) => value = newValue);
         }
 
         protected override string ConcreteSlotValueAsVariable(AbstractMaterialNode.OutputPrecision precision)

com.unity.shadergraph/Editor/Data/Graphs/Vector2ShaderProperty.cs

         {
             get { return new Vector4(value.x, value.y, 0, 0); }
         }
-       
+
         public override string GetPropertyDeclarationString(string delimiter = ";")
         {
             return string.Format("float2 {0}{1}", referenceName, delimiter);
 
         public override INode ToConcreteNode()
         {
-            return new Vector2Node { value = value };
+            var node = new Vector2Node();
+            node.FindInputSlot<Vector1MaterialSlot>(Vector2Node.InputSlotXId).value = value.x;
+            node.FindInputSlot<Vector1MaterialSlot>(Vector2Node.InputSlotYId).value = value.y;
+            return node;
         }
     }
 }

com.unity.shadergraph/Editor/Data/Graphs/Vector3MaterialSlot.cs

         [SerializeField]
         private Vector3 m_DefaultValue;
 
+        string[] m_Labels;
+
         public Vector3MaterialSlot()
         {
         }
             SlotType slotType,
             Vector3 value,
             ShaderStage shaderStage = ShaderStage.Dynamic,
+            string label1 = "X",
+            string label2 = "Y",
+            string label3 = "Z",
+            m_Labels = new[] { label1, label2, label3 };
         }
 
         public Vector3 defaultValue { get { return m_DefaultValue; } }
 
         public override VisualElement InstantiateControl()
         {
-            return new MultiFloatSlotControlView(owner, 3, () => value, (newValue) => value = newValue);
+            return new MultiFloatSlotControlView(owner, m_Labels, () => value, (newValue) => value = newValue);
         }
 
         protected override string ConcreteSlotValueAsVariable(AbstractMaterialNode.OutputPrecision precision)

com.unity.shadergraph/Editor/Data/Graphs/Vector3ShaderProperty.cs

         {
             get { return new Vector4(value.x, value.y, value.z, 0); }
         }
-        
+
         public override string GetPropertyDeclarationString(string delimiter = ";")
         {
             return string.Format("float3 {0}{1}", referenceName, delimiter);
 
         public override INode ToConcreteNode()
         {
-            return new Vector3Node { value = value };
+            var node = new Vector3Node();
+            node.FindInputSlot<Vector1MaterialSlot>(Vector3Node.InputSlotXId).value = value.x;
+            node.FindInputSlot<Vector1MaterialSlot>(Vector3Node.InputSlotYId).value = value.y;
+            node.FindInputSlot<Vector1MaterialSlot>(Vector3Node.InputSlotZId).value = value.z;
+            return node;
         }
     }
 }

com.unity.shadergraph/Editor/Data/Graphs/Vector4MaterialSlot.cs

         [SerializeField]
         private Vector4 m_DefaultValue;
 
+        string[] m_Labels;
+
         public Vector4MaterialSlot()
         {
         }
             SlotType slotType,
             Vector4 value,
             ShaderStage shaderStage = ShaderStage.Dynamic,
+            string label1 = "X",
+            string label2 = "Y",
+            string label3 = "Z",
+            string label4 = "W",
+            m_Labels = new[] { label1, label2, label3, label4 };
         }
 
         public Vector4 defaultValue { get { return m_DefaultValue; } }
 
         public override VisualElement InstantiateControl()
         {
-            return new MultiFloatSlotControlView(owner, 4, () => value, (newValue) => value = newValue);
+            return new MultiFloatSlotControlView(owner, m_Labels, () => value, (newValue) => value = newValue);
         }
 
         protected override string ConcreteSlotValueAsVariable(AbstractMaterialNode.OutputPrecision precision)

com.unity.shadergraph/Editor/Data/Graphs/Vector4ShaderProperty.cs

 
         public override INode ToConcreteNode()
         {
-            return new Vector4Node { value = value };
+            var node = new Vector4Node();
+            node.FindInputSlot<Vector1MaterialSlot>(Vector4Node.InputSlotXId).value = value.x;
+            node.FindInputSlot<Vector1MaterialSlot>(Vector4Node.InputSlotYId).value = value.y;
+            node.FindInputSlot<Vector1MaterialSlot>(Vector4Node.InputSlotZId).value = value.z;
+            node.FindInputSlot<Vector1MaterialSlot>(Vector4Node.InputSlotWId).value = value.w;
+            return node;
         }
     }
 }

com.unity.shadergraph/Editor/Data/Graphs/VertexColorMaterialSlot.cs

     {
         public VertexColorMaterialSlot(int slotId, string displayName, string shaderOutputName,
                                        ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
-            : base(slotId, displayName, shaderOutputName, SlotType.Input, Vector3.zero, shaderStage, hidden)
+            : base(slotId, displayName, shaderOutputName, SlotType.Input, Vector3.zero, shaderStage, hidden: hidden)
         {}
 
         public override VisualElement InstantiateControl()

com.unity.shadergraph/Editor/Data/Interfaces/IMayRequirePosition.cs

 
 namespace UnityEditor.ShaderGraph
 {
-    interface IMayRequirePosition
+    public interface IMayRequirePosition
     {
         NeededCoordinateSpace RequiresPosition();
     }

com.unity.shadergraph/Editor/Data/Nodes/Input/Basic/Vector1Node.cs

 using System.Collections.Generic;
+using System.Linq;
 using UnityEditor.ShaderGraph.Drawing.Controls;
 using UnityEngine;
 using UnityEditor.Graphing;
         [SerializeField]
         private float m_Value;
 
+        const string kInputSlotXName = "X";
+        const string kOutputSlotName = "Out";
+
+        public const int InputSlotXId = 1;
-        private const string kOutputSlotName = "Out";
 
         public Vector1Node()
         {
 
         public sealed override void UpdateNodeAfterDeserialization()
         {
+            AddSlot(new Vector1MaterialSlot(InputSlotXId, kInputSlotXName, kInputSlotXName, SlotType.Input, m_Value));
-            RemoveSlotsNameNotMatching(new[] { OutputSlotId });
-        }
-
-        [MultiFloatControl("")]
-        public float value
-        {
-            get { return m_Value; }
-            set
-            {
-                if (m_Value == value)
-                    return;
-
-                m_Value = value;
-
-                Dirty(ModificationScope.Node);
-            }
-        }
-
-        public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
-        {
-            if (!generationMode.IsPreview())
-                return;
-
-            properties.AddShaderProperty(new Vector1ShaderProperty()
-            {
-                overrideReferenceName = GetVariableNameForNode(),
-                generatePropertyBlock = false,
-                value = value
-            });
+            RemoveSlotsNameNotMatching(new[] { OutputSlotId, InputSlotXId });
         }
 
         public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
 
-            visitor.AddShaderChunk(precision + " " + GetVariableNameForNode() + " = " + NodeUtils.FloatToShaderValue(m_Value) + ";", true);
+            var inputValue = GetSlotValue(InputSlotXId, generationMode);
+            visitor.AddShaderChunk(precision + " " + GetVariableNameForNode() + " = " + inputValue + ";", false);
         }
 
         public override string GetVariableNameForSlot(int slotId)
 
-        public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
-        {
-            properties.Add(new PreviewProperty(PropertyType.Vector1)
-            {
-                name = GetVariableNameForNode(),
-                floatValue = m_Value
-            });
-        }
-
-            return new Vector1ShaderProperty { value = value };
+            var slot = FindInputSlot<Vector1MaterialSlot>(InputSlotXId);
+            return new Vector1ShaderProperty { value = slot.value };
-        public int outputSlotId { get { return OutputSlotId; } }
+        int IPropertyFromNode.outputSlotId { get { return OutputSlotId; } }
     }
 }

com.unity.shadergraph/Editor/Data/Nodes/Input/Basic/Vector2Node.cs

 using System.Collections.Generic;
+using System.Linq;
 using UnityEditor.ShaderGraph.Drawing.Controls;
 using UnityEngine;
 using UnityEditor.Graphing;
     {
         [SerializeField]
         private Vector2 m_Value;
+
+        const string kInputSlotXName = "X";
+        const string kInputSlotYName = "Y";
+        const string kOutputSlotName = "Out";
-        private const string kOutputSlotName = "Out";
+        public const int InputSlotXId = 1;
+        public const int InputSlotYId = 2;
+
 
         public Vector2Node()
         {
 
         public sealed override void UpdateNodeAfterDeserialization()
         {
+            AddSlot(new Vector1MaterialSlot(InputSlotXId, kInputSlotXName, kInputSlotXName, SlotType.Input, m_Value.x));
+            AddSlot(new Vector1MaterialSlot(InputSlotYId, kInputSlotYName, kInputSlotYName, SlotType.Input, m_Value.y, label1: "Y"));
-            RemoveSlotsNameNotMatching(new[] { OutputSlotId });
-        }
-
-        [MultiFloatControl("")]
-        public Vector2 value
-        {
-            get { return m_Value; }
-            set
-            {
-                if (m_Value == value)
-                    return;
-
-                m_Value = value;
-
-                Dirty(ModificationScope.Node);
-            }
-        }
-
-        public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
-        {
-            if (!generationMode.IsPreview())
-                return;
-
-            properties.AddShaderProperty(new Vector2ShaderProperty()
-            {
-                overrideReferenceName = GetVariableNameForNode(),
-                generatePropertyBlock = false,
-                value = value
-            });
+            RemoveSlotsNameNotMatching(new[] { OutputSlotId, InputSlotXId, InputSlotYId });
-            if (generationMode.IsPreview())
-                return;
-
-            visitor.AddShaderChunk(string.Format("{0}2 {1} = {0}2({2},{3});", precision, GetVariableNameForNode(), NodeUtils.FloatToShaderValue(m_Value.x), NodeUtils.FloatToShaderValue(m_Value.y)), true);
-        }
+            var inputXValue = GetSlotValue(InputSlotXId, generationMode);
+            var inputYValue = GetSlotValue(InputSlotYId, generationMode);
+            var outputName = GetVariableNameForSlot(OutputSlotId);
-        public override string GetVariableNameForSlot(int slotId)
-        {
-            return GetVariableNameForNode();
-        }
-
-        public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
-        {
-            properties.Add(new PreviewProperty(PropertyType.Vector2)
-            {
-                name = GetVariableNameForNode(),
-                vector4Value = m_Value
-            });
+            var s = string.Format("{0}2 {1} = {0}2({2},{3});",
+                precision,
+                outputName,
+                inputXValue,
+                inputYValue);
+            visitor.AddShaderChunk(s, false);
-            return new Vector2ShaderProperty { value = value };
+            var slotX = FindInputSlot<Vector1MaterialSlot>(InputSlotXId);
+            var slotY = FindInputSlot<Vector1MaterialSlot>(InputSlotYId);
+            return new Vector2ShaderProperty { value = new Vector2(slotX.value, slotY.value) };
-        public int outputSlotId { get { return OutputSlotId; } }
+        int IPropertyFromNode.outputSlotId { get { return OutputSlotId; } }
     }
 }

com.unity.shadergraph/Editor/Data/Nodes/Input/Basic/Vector3Node.cs

         [SerializeField]
         private Vector3 m_Value;
 
+        const string kInputSlotXName = "X";
+        const string kInputSlotYName = "Y";
+        const string kInputSlotZName = "Z";
+        const string kOutputSlotName = "Out";
+
-        private const string kOutputSlotName = "Out";
+        public const int InputSlotXId = 1;
+        public const int InputSlotYId = 2;
+        public const int InputSlotZId = 3;
+
 
         public Vector3Node()
         {
 
         public sealed override void UpdateNodeAfterDeserialization()
         {
+            AddSlot(new Vector1MaterialSlot(InputSlotXId, kInputSlotXName, kInputSlotXName, SlotType.Input, m_Value.x));
+            AddSlot(new Vector1MaterialSlot(InputSlotYId, kInputSlotYName, kInputSlotYName, SlotType.Input, m_Value.y, label1: "Y"));
+            AddSlot(new Vector1MaterialSlot(InputSlotZId, kInputSlotZName, kInputSlotZName, SlotType.Input, m_Value.z, label1: "Z"));
-            RemoveSlotsNameNotMatching(new[] { OutputSlotId });
-        }
-
-        [MultiFloatControl("")]
-        public Vector3 value
-        {
-            get { return m_Value; }
-            set
-            {
-                if (m_Value == value)
-                    return;
-
-                m_Value = value;
-
-                Dirty(ModificationScope.Node);
-            }
-        }
-
-        public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
-        {
-            if (!generationMode.IsPreview())
-                return;
-
-            properties.AddShaderProperty(new Vector3ShaderProperty()
-            {
-                overrideReferenceName = GetVariableNameForNode(),
-                generatePropertyBlock = false,
-                value = value
-            });
+            RemoveSlotsNameNotMatching(new[] { OutputSlotId, InputSlotXId, InputSlotYId, InputSlotZId });
-            if (generationMode.IsPreview())
-                return;
+            var inputXValue = GetSlotValue(InputSlotXId, generationMode);
+            var inputYValue = GetSlotValue(InputSlotYId, generationMode);
+            var inputZValue = GetSlotValue(InputSlotZId, generationMode);
+            var outputName = GetVariableNameForSlot(outputSlotId);
-                GetVariableNameForNode(),
-                NodeUtils.FloatToShaderValue(m_Value.x),
-                NodeUtils.FloatToShaderValue(m_Value.y),
-                NodeUtils.FloatToShaderValue(m_Value.z));
-            visitor.AddShaderChunk(s, true);
-        }
-
-        public override string GetVariableNameForSlot(int slotId)
-        {
-            return GetVariableNameForNode();
-        }
-
-        public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
-        {
-            properties.Add(new PreviewProperty(PropertyType.Vector3)
-            {
-                name = GetVariableNameForNode(),
-                vector4Value = m_Value
-            });
+                outputName,
+                inputXValue,
+                inputYValue,
+                inputZValue);
+            visitor.AddShaderChunk(s, false);
-            return new Vector3ShaderProperty { value = value };
+            var slotX = FindInputSlot<Vector1MaterialSlot>(InputSlotXId);
+            var slotY = FindInputSlot<Vector1MaterialSlot>(InputSlotYId);
+            var slotZ = FindInputSlot<Vector1MaterialSlot>(InputSlotZId);
+            return new Vector3ShaderProperty { value = new Vector3(slotX.value, slotY.value, slotZ.value) };
         }
 
         public int outputSlotId { get { return OutputSlotId; } }

com.unity.shadergraph/Editor/Data/Nodes/Input/Basic/Vector4Node.cs

         [SerializeField]
         private Vector4 m_Value;
 
+        const string kInputSlotXName = "X";
+        const string kInputSlotYName = "Y";
+        const string kInputSlotZName = "Z";
+        const string kInputSlotWName = "W";
+        const string kOutputSlotName = "Out";
+
-        private const string kOutputSlotName = "Out";
+        public const int InputSlotXId = 1;
+        public const int InputSlotYId = 2;
+        public const int InputSlotZId = 3;
+        public const int InputSlotWId = 4;
+
 
         public Vector4Node()
         {
 
         public sealed override void UpdateNodeAfterDeserialization()
         {
+            AddSlot(new Vector1MaterialSlot(InputSlotXId, kInputSlotXName, kInputSlotXName, SlotType.Input, m_Value.x));
+            AddSlot(new Vector1MaterialSlot(InputSlotYId, kInputSlotYName, kInputSlotYName, SlotType.Input, m_Value.y, label1: "Y"));
+            AddSlot(new Vector1MaterialSlot(InputSlotZId, kInputSlotZName, kInputSlotZName, SlotType.Input, m_Value.z, label1: "Z"));
+            AddSlot(new Vector1MaterialSlot(InputSlotWId, kInputSlotWName, kInputSlotWName, SlotType.Input, m_Value.w, label1: "W"));
-            RemoveSlotsNameNotMatching(new[] { OutputSlotId });
-        }
-
-        [MultiFloatControl("")]
-        public Vector4 value
-        {
-            get { return m_Value; }
-            set
-            {
-                if (m_Value == value)
-                    return;
-
-                m_Value = value;
-
-                Dirty(ModificationScope.Node);
-            }
-        }
-
-        public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
-        {
-            if (!generationMode.IsPreview())
-                return;
-
-            properties.AddShaderProperty(new Vector4ShaderProperty()
-            {
-                overrideReferenceName = GetVariableNameForNode(),
-                generatePropertyBlock = false,
-                value = value
-            });
+            RemoveSlotsNameNotMatching(new[] { OutputSlotId, InputSlotXId, InputSlotYId, InputSlotZId, InputSlotWId });
-            if (generationMode.IsPreview())
-                return;
+            var inputXValue = GetSlotValue(InputSlotXId, generationMode);
+            var inputYValue = GetSlotValue(InputSlotYId, generationMode);
+            var inputZValue = GetSlotValue(InputSlotZId, generationMode);
+            var inputWValue = GetSlotValue(InputSlotWId, generationMode);
+            var outputName = GetVariableNameForSlot(outputSlotId);
-                GetVariableNameForNode(),
-                NodeUtils.FloatToShaderValue(m_Value.x),
-                NodeUtils.FloatToShaderValue(m_Value.y),
-                NodeUtils.FloatToShaderValue(m_Value.z),
-                NodeUtils.FloatToShaderValue(m_Value.w));
+                outputName,
+                inputXValue,
+                inputYValue,
+                inputZValue,
+                inputWValue);
-        public override string GetVariableNameForSlot(int slotId)
-        {
-            return GetVariableNameForNode();
-        }
-
-        public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
-        {
-            properties.Add(new PreviewProperty(PropertyType.Vector4)
-            {
-                name = GetVariableNameForNode(),
-                vector4Value = m_Value
-            });
-        }
-
-            return new Vector4ShaderProperty { value = value };
+            var slotX = FindInputSlot<Vector1MaterialSlot>(InputSlotXId);
+            var slotY = FindInputSlot<Vector1MaterialSlot>(InputSlotYId);
+            var slotZ = FindInputSlot<Vector1MaterialSlot>(InputSlotZId);
+            var slotW = FindInputSlot<Vector1MaterialSlot>(InputSlotWId);
+            return new Vector4ShaderProperty { value = new Vector4(slotX.value, slotY.value, slotZ.value, slotW.value) };
         }
 
         public int outputSlotId { get { return OutputSlotId; } }

com.unity.shadergraph/Editor/Data/Nodes/SlotValue.cs

 
     public static class SlotValueHelper
     {
-        public static int GetChannelCount(ConcreteSlotValueType type)
+        public static int GetChannelCount(this ConcreteSlotValueType type)
         {
             switch (type)
             {

com.unity.shadergraph/Editor/Drawing/Blackboard/BlackboardFieldPropertyView.cs

             else if (property is BooleanShaderProperty)
             {
                 var booleanProperty = (BooleanShaderProperty)property;
-                Action onBooleanChanged = () => 
-                { 
+                Action onBooleanChanged = () =>
+                {
-                var field = new Toggle(onBooleanChanged) { on = booleanProperty.value };
+                var field = new Toggle(onBooleanChanged);
+                field.SetValue(booleanProperty.value);
                 AddRow("Default", field);
             }
 //            AddRow("Type", new TextField());

com.unity.shadergraph/Editor/Drawing/Controls/ChannelEnumControl.cs

 
         public ChannelEnumControlView(string label, int slotId, AbstractMaterialNode node, PropertyInfo propertyInfo)
         {
+            AddStyleSheetPath("Styles/Controls/ChannelEnumControlView");
             m_Node = node;
             m_PropertyInfo = propertyInfo;
             m_SlotId = slotId;

com.unity.shadergraph/Editor/Drawing/Controls/ChannelEnumMaskControl.cs

 
         public ChannelEnumMaskControlView(string label, int slotId, AbstractMaterialNode node, PropertyInfo propertyInfo)
         {
+            AddStyleSheetPath("Styles/Controls/ChannelEnumMaskControlView");
             m_Node = node;
             m_PropertyInfo = propertyInfo;
             m_SlotId = slotId;

com.unity.shadergraph/Editor/Drawing/Controls/IntegerControl.cs

 
             var intField = new IntegerField { value = (int)m_PropertyInfo.GetValue(m_Node, null) };
             intField.OnValueChanged(OnChange);
+
+#if UNITY_2018_1
+#else
+        void OnChange(ChangeEvent<int> evt)
+#endif
-            m_PropertyInfo.SetValue(m_Node, (int)evt.newValue, null);
+            var newValue =
+#if UNITY_2018_1
+                (int)
+#endif
+                evt.newValue;
+            m_PropertyInfo.SetValue(m_Node, newValue, null);
             Dirty(ChangeType.Repaint);
         }
     }

com.unity.shadergraph/Editor/Drawing/Controls/ToggleControl.cs

             Action changedToggle = () => { OnChangeToggle(); };
             m_Toggle = new UnityEngine.Experimental.UIElements.Toggle(changedToggle);
             m_Toggle.SetEnabled(value.isEnabled);
-            m_Toggle.on = value.isOn;
+            m_Toggle.SetValue(value.isOn);
             panel.Add(m_Toggle);
             Add(panel);
         }

com.unity.shadergraph/Editor/Drawing/Views/Slots/MultiFloatSlotControlView.cs

         readonly Action<Vector4> m_Set;
         int m_UndoGroup = -1;
 
-        public MultiFloatSlotControlView(INode node, int components, Func<Vector4> get, Action<Vector4> set)
+        public MultiFloatSlotControlView(INode node, string[] labels, Func<Vector4> get, Action<Vector4> set)
         {
             AddStyleSheetPath("Styles/Controls/MultiFloatSlotControlView");
             m_Node = node;
-            AddField(initialValue, 0, "X");
-            if (components > 1)
-                AddField(initialValue, 1, "Y");
-            if (components > 2)
-                AddField(initialValue, 2, "Z");
-            if (components > 3)
-                AddField(initialValue, 3, "W");
+            for (var i = 0; i < labels.Length; i++)
+                AddField(initialValue, i, labels[i]);
         }
 
         void AddField(Vector4 initialValue, int index, string subLabel)

com.unity.shadergraph/Editor/Resources/Styles/Controls/EnumControlView.uss

 }
 
 EnumControlView > EnumField {
+    width: 80;
     flex: 1;
     margin-left: 0;
     margin-right: 8;
 
 EnumControlView > Label {
+    width: 100;
     padding-left: 0;
     padding-right: 0;
     padding-top: 0;

com.unity.shadergraph/Editor/Util/CompatibilityExtensions.cs

             Debug.Assert(action != null);
             contextualMenu.AppendAction(actionName, e => action(), e => statusFlags);
         }
+
+        public static bool GetValue(this Toggle toggle)
+        {
+#if UNITY_2018_1
+            return toggle.on;
+#else
+            return toggle.value;
+#endif
+        }
+
+        public static void SetValue(this Toggle toggle, bool value)
+        {
+#if UNITY_2018_1
+            toggle.on = value;
+#else
+            toggle.value = value;
+#endif
+        }
     }
 }

com.unity.shadergraph/Editor/Resources/Styles/Controls/ChannelEnumControlView.uss

+ChannelEnumControlView {
+    flex-direction: row;
+    flex: 1;
+    padding-left: 8;
+    padding-right: 8;
+    padding-top: 4;
+    padding-bottom: 4;
+    width: 200;
+}

com.unity.shadergraph/Editor/Resources/Styles/Controls/ChannelEnumControlView.uss.meta

+fileFormatVersion: 2
+guid: 8dfac6eef2d89e8428c7a79b147413db
+ScriptedImporter:
+  fileIDToRecycleName:
+    11400000: stylesheet
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}

com.unity.shadergraph/Editor/Resources/Styles/Controls/ChannelEnumMaskControlView.uss

+ChannelEnumMaskControlView {
+    flex-direction: row;
+    flex: 1;
+    padding-left: 8;
+    padding-right: 8;
+    padding-top: 4;
+    padding-bottom: 4;
+    width: 200;
+}

com.unity.shadergraph/Editor/Resources/Styles/Controls/ChannelEnumMaskControlView.uss.meta

+fileFormatVersion: 2
+guid: 1db7b9bf1f9186d44ba7fefd3bc715c6
+ScriptedImporter:
+  fileIDToRecycleName:
+    11400000: stylesheet
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}