[shader graph]Update update some nodes to have multiple outputs.

UnityProject/Assets/UnityShaderEditor/Editor/Source/Editors/BaseMaterialNodeEditor.cs

 
         private static void DoMaterialSlotUIBody(BaseMaterialNode node, Slot slot)
         {
-            SlotDefaultValue defaultValue = node.GetSlotDefaultValue(slot.name);
-            if (defaultValue == null)
+            SlotValue value = node.GetSlotDefaultValue(slot.name);
+            if (value == null)
                 return;
             
             var def = node.GetSlotDefaultValue(slot.name);

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/BaseMaterialNode.cs

         [SerializeField]
         public string slotName;
         [SerializeField]
-        public SlotDefaultValue defaultValue;
+        public SlotValue value;
-        public SlotDefaultValueKVP(string slotName, SlotDefaultValue defaultValue)
+        public SlotDefaultValueKVP(string slotName, SlotValue value)
-            this.defaultValue = defaultValue;
+            this.value = value;
         }
     } 
     
-        public SlotDefaultValue defaultValue;
+        public SlotValueType valueType;
-        public MaterialGraphSlot(Slot slot, SlotDefaultValue defaultValue)
+        public MaterialGraphSlot(Slot slot, SlotValueType valueType)
-            this.defaultValue = defaultValue;
+            this.valueType = valueType;
-            return string.Format("{0} - {1} - {2}", slot.name, slot.isInputSlot, defaultValue);
+            return string.Format("{0} - {1} - {2}", slot.name, slot.isInputSlot, valueType);
         }
     }
 
         public bool isSelected { get; set; }
 
         // lookup custom slot properties
-        public void SetSlotDefaultValue(string slotName, SlotDefaultValue defaultValue)
+        public void SetSlotDefaultValue(string slotName, SlotValue defaultValue)
         {
             m_SlotDefaultValues.RemoveAll(x => x.slotName == slotName);
 
             m_SlotDefaultValues.Add(new SlotDefaultValueKVP(slotName, defaultValue));
         }
         
-        private void UpdateDefaultSlotValueIfNull(string slotName, SlotDefaultValue defaultValue)
-        {
-            var found = m_SlotDefaultValues.FirstOrDefault(x => x.slotName == slotName);
-
-            if (found == null || found.defaultValue == null)
-                SetSlotDefaultValue(slotName, defaultValue);
-
-            m_SlotDefaultValues.Add(new SlotDefaultValueKVP(slotName, defaultValue));
-        }
-
         public string precision
         {
             get { return "half"; }
 
-        public SlotDefaultValue GetSlotDefaultValue(string slotName)
+        public SlotValue GetSlotDefaultValue(string slotName)
-            return found != null ? found.defaultValue : null;
+            return found != null ? found.value : null;
         }
 
         private static Shader s_DefaultPreviewShader;
         {
             return name + "_" + Math.Abs(GetInstanceID());
         }
-        public virtual Vector4 GetNewSlotDefaultValue()
+        public virtual Vector4 GetNewSlotDefaultValue(SlotValueType type)
         {
             return Vector4.one;
         }
             {
                 base.AddSlot(slot);
             }
+
+            var slotValue = GetSlotDefaultValue(slot.name);
+            if (slotValue == null || !slotValue.IsValid())
+                SetSlotDefaultValue(slot.name, new SlotValue(this, slot.name, GetNewSlotDefaultValue(mgSlot.valueType)));
 
             // slots are not serialzied but the default values are
             // because of this we need to see if the default has
             MaterialWindow.DebugMaterialGraph("Node Name: " + GetOutputVariableNameForNode());
 
-            SetSlotDefaultValue(slot.name, mgSlot.defaultValue);
         }
 
         public override void RemoveSlot(Slot slot)
             {
                 if (inputSlot.edges.Count > 0)
                     continue;
+
+                Debug.LogFormat("On {0} and trying to genereate for {1}", this, inputSlot);
 
                 var defaultForSlot = GetSlotDefaultValue(inputSlot.name);
                 if (defaultForSlot != null)
         {
             var invalidSlots = slots.Select(x => x.name).Except(slotNames);
 
-            foreach (var invalidSlot in invalidSlots)
+            foreach (var invalidSlot in invalidSlots.ToList())
             {
                 Debug.LogWarningFormat("Removing Invalid Slot: {0}", invalidSlot);
                 RemoveSlot(this[invalidSlot]);

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/ColorNode.cs

         public override void OnEnable()
         {
             base.OnEnable();
-            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotName), null));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotName), SlotValueType.Vector4));
         }
 
         public override PropertyType propertyType

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/Function1Input.cs

         protected virtual MaterialGraphSlot GetInputSlot()
         {
             var slot = new Slot(SlotType.InputSlot, GetInputSlotName());
-            return new MaterialGraphSlot(slot, new SlotDefaultValue(this, slot.name, GetNewSlotDefaultValue(), SlotValueType.Vector4Dynamic));
+            return new MaterialGraphSlot(slot, SlotValueType.Vector4Dynamic);
-            return new MaterialGraphSlot(slot, null);
-
+            return new MaterialGraphSlot(slot, SlotValueType.Vector4Dynamic);
         }
 
         protected virtual string GetInputSlotName() {return "Input"; }

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/Function2Input.cs

         protected virtual MaterialGraphSlot GetInputSlot1()
         {
             var slot = new Slot(SlotType.InputSlot, GetInputSlot1Name());
-            return new MaterialGraphSlot(slot, new SlotDefaultValue(this, slot.name, GetNewSlotDefaultValue(), SlotValueType.Vector4Dynamic));
+            return new MaterialGraphSlot(slot, SlotValueType.Vector4Dynamic);
-            return new MaterialGraphSlot(slot, new SlotDefaultValue(this, slot.name, GetNewSlotDefaultValue(), SlotValueType.Vector4Dynamic));
+            return new MaterialGraphSlot(slot, SlotValueType.Vector4Dynamic);
-            return new MaterialGraphSlot(slot, null);
-
+            return new MaterialGraphSlot(slot, SlotValueType.Vector4Dynamic);
         }
         
         protected virtual string GetInputSlot1Name()

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/Function3Input.cs

         protected virtual MaterialGraphSlot GetInputSlot1()
         {
             var slot = new Slot(SlotType.InputSlot, GetInputSlot1Name());
-            return new MaterialGraphSlot(slot, new SlotDefaultValue(this, slot.name, GetNewSlotDefaultValue(), SlotValueType.Vector4Dynamic));
+            return new MaterialGraphSlot(slot, SlotValueType.Vector4Dynamic);
-            return new MaterialGraphSlot(slot, new SlotDefaultValue(this, slot.name, GetNewSlotDefaultValue(), SlotValueType.Vector4Dynamic));
+            return new MaterialGraphSlot(slot, SlotValueType.Vector4Dynamic);
-            return new MaterialGraphSlot(slot, new SlotDefaultValue(this, slot.name, GetNewSlotDefaultValue(), SlotValueType.Vector4Dynamic));
+            return new MaterialGraphSlot(slot, SlotValueType.Vector4Dynamic);
 
         }
 
-            return new MaterialGraphSlot(slot, null);
+            return new MaterialGraphSlot(slot, SlotValueType.Vector4Dynamic);
         }
 
         protected virtual string GetInputSlot1Name()

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/MultiplyNode.cs

 
         protected override string GetFunctionName() { return "unity_multiply_" + precision; }
 
-        public override Vector4 GetNewSlotDefaultValue()
-        {
-            return Vector4.one;
-        }
-
         public void GenerateNodeFunction(ShaderGenerator visitor, GenerationMode generationMode)
         {
             var outputString = new ShaderGenerator();

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/NormalNode.cs

         public override void OnEnable()
         {
             base.OnEnable();
-            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotName), null));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotName), SlotValueType.Vector3));
         }
 
         public override string GetOutputVariableNameForSlot(Slot slot, GenerationMode generationMode)

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/PerlinNode.cs

-using UnityEditor.Graphs;
 using UnityEngine;
 
 namespace UnityEditor.MaterialGraph
             visitor.AddShaderChunk(outputString.GetShaderString(0), true);
         }
 
-        public override void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
+      /*  public override void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
         {
             var outputSlot = FindOutputSlot(kOutputSlotName);
             if (outputSlot == null)
             string body = "unity_perlin_" + precision + "(" + GetPropertyName() + ", " + m_Iterations + ", " + m_Decay + ", " + m_Frequency + ", " + uvName + ".xy)";
             visitor.AddShaderChunk("float4 " + GetOutputVariableNameForSlot(outputSlot, generationMode) + " = " + body + ";", true);
         }
-
+        */
         static float Slider(string title, float value, float from, float to)
         {
             GUILayout.BeginHorizontal();

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/PixelShaderNode.cs

         {
             base.OnEnable();
 
-            AddSlot(new MaterialGraphSlot(new Slot(SlotType.InputSlot, kAlbedoSlotName), null));
-            AddSlot(new MaterialGraphSlot(new Slot(SlotType.InputSlot, kNormalSlotName), null));
-            AddSlot(new MaterialGraphSlot(new Slot(SlotType.InputSlot, kSpecularSlotName), null));
-            AddSlot(new MaterialGraphSlot(new Slot(SlotType.InputSlot, kEmissionSlotName), null));
-            AddSlot(new MaterialGraphSlot(new Slot(SlotType.InputSlot, kMetallicSlotName), null));
-            AddSlot(new MaterialGraphSlot(new Slot(SlotType.InputSlot, kSmoothnessSlotName), null));
-            AddSlot(new MaterialGraphSlot(new Slot(SlotType.InputSlot, kOcclusion), null));
-            AddSlot(new MaterialGraphSlot(new Slot(SlotType.InputSlot, kAlphaSlotName), null));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.InputSlot, kAlbedoSlotName), SlotValueType.Vector3));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.InputSlot, kNormalSlotName), SlotValueType.Vector3));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.InputSlot, kSpecularSlotName), SlotValueType.Vector1));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.InputSlot, kEmissionSlotName), SlotValueType.Vector3));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.InputSlot, kMetallicSlotName), SlotValueType.Vector1));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.InputSlot, kSmoothnessSlotName), SlotValueType.Vector1));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.InputSlot, kOcclusion), SlotValueType.Vector1));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.InputSlot, kAlphaSlotName), SlotValueType.Vector1));
 
             // clear out slot names that do not match the slots 
             // we support

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/PropertyNode.cs

         public virtual string GetPropertyName()
         {
             if (m_BoundProperty == null)
-                return name + "_" + Math.Abs(GetInstanceID());
+                return name + "_" + Math.Abs(GetInstanceID()) + "_Uniform";
 
             return m_BoundProperty.name;
         }

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/ScreenPosNode.cs

         public override void OnEnable()
         {
             base.OnEnable();
-            AddSlot(new MaterialGraphSlot(new Slot(SlotType.InputSlot, kOutputSlotName), null));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.InputSlot, kOutputSlotName),  SlotValueType.Vector4));
         }
 
         public override string GetOutputVariableNameForSlot(Slot slot, GenerationMode generationMode)

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/SinTimeNode.cs

         public override void OnEnable()
         {
             base.OnEnable();
-            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotName), null));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotName), SlotValueType.Vector4));
         }
 
         public override bool hasPreview

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/TextureNode.cs

     [Title("Input/Texture Node")]
     public class TextureNode : PropertyNode, IGeneratesBodyCode, IGeneratesVertexShaderBlock, IGeneratesVertexToFragmentBlock
     {
-        protected const string kOutputSlotName = "Output";
+        protected const string kOutputSlotRGBAName = "RGBA";
+        protected const string kOutputSlotRName = "R";
+        protected const string kOutputSlotGName = "G";
+        protected const string kOutputSlotBName = "B";
+        protected const string kOutputSlotAName = "A";
         protected const string kUVSlotName = "UV";
 
         [SerializeField]
         {
             name = "Texture";
             base.OnCreate();
-           LoadTextureTypes();
+            LoadTextureTypes();
-            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotName), null));
-            AddSlot(new MaterialGraphSlot(new Slot(SlotType.InputSlot, kUVSlotName), null));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotRGBAName), SlotValueType.Vector4));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotRName), SlotValueType.Vector1));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotGName), SlotValueType.Vector1));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotBName), SlotValueType.Vector1));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotAName), SlotValueType.Vector1));
+            
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.InputSlot, kUVSlotName), SlotValueType.Vector2));
+
+            RemoveSlotsNameNotMatching(validSlots);
+        }
+
+        protected string[] validSlots
+        {
+            get { return new[] {kOutputSlotRGBAName, kOutputSlotRName, kOutputSlotGName, kOutputSlotBName, kOutputSlotAName, kUVSlotName}; }
         }
 
         private void LoadTextureTypes()
         // Node generations
         public virtual void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
         {
-            var outputSlot = FindOutputSlot(kOutputSlotName);
-            if (outputSlot == null)
-                return;
-
             var uvSlot = FindInputSlot(kUVSlotName);
             if (uvSlot == null)
                 return;
             string body = "tex2D (" + GetPropertyName() + ", " + uvName + ".xy)";
             if (m_TextureType == TextureType.Bump)
                 body = precision + "4(UnpackNormal(" + body + "), 0)";
-            visitor.AddShaderChunk("float4 " + GetOutputVariableNameForSlot(outputSlot, generationMode) + " = " + body + ";", true);
+            visitor.AddShaderChunk("float4 " + GetOutputVariableNameForNode() + " = " + body + ";", true);
+        }
+
+        public override string GetOutputVariableNameForSlot(Slot s, GenerationMode generationMode)
+        {
+            string slotOutput;
+            switch (s.name)
+            {
+                case kOutputSlotRName:
+                    slotOutput = ".r";
+                    break;
+                case kOutputSlotGName:
+                    slotOutput = ".g";
+                    break;
+                case kOutputSlotBName:
+                    slotOutput = ".b";
+                    break;
+                case kOutputSlotAName:
+                    slotOutput = ".a";
+                    break;
+                default:
+                    slotOutput = "";
+                    break;
+            }
+            return GetOutputVariableNameForNode() + slotOutput;
         }
 
         public void GenerateVertexToFragmentBlock(ShaderGenerator visitor, GenerationMode generationMode)

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/TimeNode.cs

     public class TimeNode : BaseMaterialNode, IRequiresTime
     {
         private const string kOutputSlotName = "Time";
+        private const string kOutputSlotNameX = "Time.x";
+        private const string kOutputSlotNameY = "Time.y";
+        private const string kOutputSlotNameZ = "Time.z";
+        private const string kOutputSlotNameW = "Time.w";
 
         public override void OnCreate()
         {
         public override void OnEnable()
         {
             base.OnEnable();
-            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotName), null));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotName), SlotValueType.Vector4));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotNameX), SlotValueType.Vector1));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotNameY), SlotValueType.Vector1));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotNameZ), SlotValueType.Vector1));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotNameW), SlotValueType.Vector1));
-            return "_Time";
+            switch (s.name)
+            {
+                case kOutputSlotNameX:
+                    return "_Time.x";
+                case kOutputSlotNameY:
+                    return "_Time.y";
+                case kOutputSlotNameZ:
+                    return "_Time.z";
+                case kOutputSlotNameW:
+                    return "_Time.w";
+                default:
+                    return "_Time";
+            }
         }
     }
 }

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/UVNode.cs

         public override void OnEnable()
         {
             base.OnEnable();
-            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotName), null));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotName),  SlotValueType.Vector4));
         }
 
         public static void StaticGenerateVertexToFragmentBlock(ShaderGenerator visitor, GenerationMode generationMode)

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/Vector1Node.cs

         public override void OnEnable()
         {
             base.OnEnable();
-            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotName), null));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotName), SlotValueType.Vector1));
         }
 
         public override PropertyType propertyType

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/Vector4Node.cs

         public override void OnEnable()
         {
             base.OnEnable();
-            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotName), null));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotName), SlotValueType.Vector4));
         }
 
         public override PropertyType propertyType

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/ViewDirectionNode.cs

         public override void OnEnable()
         {
             base.OnEnable();
-            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotName), null));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotName), SlotValueType.Vector3));
         }
 
         public override string GetOutputVariableNameForSlot(Slot slot, GenerationMode generationMode)

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/WorldPosNode.cs

         public override void OnEnable()
         {
             base.OnEnable();
-            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotName), null));
+            AddSlot(new MaterialGraphSlot(new Slot(SlotType.OutputSlot, kOutputSlotName), SlotValueType.Vector3));
         }
 
         public override string GetOutputVariableNameForSlot(Slot slot, GenerationMode generationMode)

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/SlotValue.cs

                     return null;
                 var properties = node[slot];
                 if (properties != null && properties.supportsDefault)
-                    return properties.defaultValue;
+                    return properties.value;
                 return null;
             }
 
                     return;
                 var properties = node[slot];
                 if (properties != null && properties.supportsDefault) {
-                    Object.DestroyImmediate (properties.defaultValue, true);
-                    properties.defaultValue = value;
+                    Object.DestroyImmediate (properties.value, true);
+                    properties.value = value;
-                    properties = new SlotProperties() {defaultValue = value};
+                    properties = new SlotProperties() {value = value};
                     slot.SetPropertiesForSlot (properties);
                 }
             }
                     return;
                 int index = node.m_SlotPropertiesIndexes.FindIndex (x => x == slot.name);
                 var oldValue = index > -1 ? node.m_SlotProperties[index] : null;
-                if (oldValue != null && oldValue.defaultValue != null)
-                    Object.DestroyImmediate (oldValue.defaultValue, true);
+                if (oldValue != null && oldValue.value != null)
+                    Object.DestroyImmediate (oldValue.value, true);
-                        oldValue.defaultValue = null;
+                        oldValue.value = null;
                     node.m_SlotPropertiesIndexes.RemoveAt (index);
                     node.m_SlotProperties.RemoveAt (index);
                 }
     }
 
     [Serializable]
-    public class SlotDefaultValue : IGenerateProperties
+    public class SlotValue : IGenerateProperties
     {
         [SerializeField]
         private Vector4 m_DefaultVector;
         }
 
-        [SerializeField] 
-        private SlotValueType m_SlotValueType;
-        public SlotValueType slotValueType
-        {
-            get { return m_SlotValueType; }
-        }
-
         [SerializeField]
         private string m_SlotName;
         public string slotName
             get { return m_Node.GetOutputVariableNameForNode(); }
         }
 
-        public SlotDefaultValue(BaseMaterialNode node, string slotName, Vector4 value, SlotValueType valueType)
+        public SlotValue(BaseMaterialNode node, string slotName, Vector4 value)
-            m_SlotValueType = valueType;
+        }
+
+        public bool IsValid()
+        {
+            return !string.IsNullOrEmpty(m_SlotName) && m_Node != null;
         }
 
         public void GeneratePropertyBlock(PropertyGenerator visitor, GenerationMode generationMode)

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/SlotValue.cs.meta

+fileFormatVersion: 2
+guid: 226fc3c1379acec4b921a0ac0f986089
+timeCreated: 1446027539
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/SlotDefaultValue.cs.meta

-fileFormatVersion: 2
-guid: aa0b7c1acda2323448f4c92093e2acca
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: