Various clean-ups to make code a bit more neat

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/AbstractMaterialGraph.cs

                     foundEdges.Add(edge);
             }
         }
+
         public virtual void CollectShaderProperties(PropertyCollector collector, GenerationMode generationMode)
         {
             foreach (var prop in properties)
-        public virtual void AddShaderProperty(IShaderProperty property)
+        public void AddShaderProperty(IShaderProperty property)
         {
             if (property == null)
                 return;
         {
             var propertyNodes = GetNodes<PropertyNode>().Where(x => x.propertyGuid == guid).ToList();
             foreach (var propNode in propertyNodes)
-                ReplacePropertyNodeWithConcreteNode(propNode);
+                ReplacePropertyNodeWithConcreteNodeNoValidate(propNode);
 
             RemoveShaderPropertyNoValidate(guid);
 
 
         public void ReplacePropertyNodeWithConcreteNode(PropertyNode propertyNode)
         {
+            ReplacePropertyNodeWithConcreteNodeNoValidate(propertyNode);
+            ValidateGraph();
+        }
+
+        void ReplacePropertyNodeWithConcreteNodeNoValidate(PropertyNode propertyNode)
+        {
-            if (property != null)
-            {
-                AbstractMaterialNode node = null;
-                int slotId = -1;
-                if (property is FloatShaderProperty)
-                {
-                    var createdNode = new Vector1Node();
-                    createdNode.value = ((FloatShaderProperty)property).value;
-                    slotId = Vector1Node.OutputSlotId;
-                    node = createdNode;
-                }
-                else if (property is Vector2ShaderProperty)
-                {
-                    var createdNode = new Vector2Node();
-                    createdNode.value = ((Vector2ShaderProperty)property).value;
-                    slotId = Vector2Node.OutputSlotId;
-                    node = createdNode;
-                }
-                else if (property is Vector3ShaderProperty)
-                {
-                    var createdNode = new Vector3Node();
-                    createdNode.value = ((Vector3ShaderProperty)property).value;
-                    slotId = Vector3Node.OutputSlotId;
-                    node = createdNode;
-                }
-                else if (property is Vector4ShaderProperty)
-                {
-                    var createdNode = new Vector4Node();
-                    createdNode.value = ((Vector4ShaderProperty)property).value;
-                    slotId = Vector4Node.OutputSlotId;
-                    node = createdNode;
-                }
-                else if (property is ColorShaderProperty)
-                {
-                    var createdNode = new ColorNode();
-                    createdNode.color = ((ColorShaderProperty)property).value;
-                    slotId = ColorNode.OutputSlotId;
-                    node = createdNode;
-                }
-                else if (property is TextureShaderProperty)
-                {
-                    var createdNode = new Texture2DAssetNode();
-                    createdNode.texture = ((TextureShaderProperty)property).value.texture;
-                    slotId = Texture2DAssetNode.OutputSlotId;
-                    node = createdNode;
-                }
-                else if (property is CubemapShaderProperty)
-                {
-                    var createdNode = new CubemapAssetNode();
-                    createdNode.cubemap = ((CubemapShaderProperty)property).value.cubemap;
-                    slotId = CubemapAssetNode.OutputSlotId;
-                    node = createdNode;
-                }
+            if (property == null)
+                return;
+
+            var node = property.ToConcreteNode();
+            if (!(node is AbstractMaterialNode))
+                return;
-                if (node == null)
-                    return;
+            var slot = propertyNode.FindOutputSlot<MaterialSlot>(PropertyNode.OutputSlotId);
+            var newSlot = node.GetOutputSlots<MaterialSlot>().FirstOrDefault(s => s.valueType == slot.valueType);
+            if (newSlot == null)
+                return;
-                var slot = propertyNode.FindOutputSlot<MaterialSlot>(PropertyNode.OutputSlotId);
-                node.drawState = propertyNode.drawState;
-                AddNodeNoValidate(node);
+            node.drawState = propertyNode.drawState;
+            AddNodeNoValidate(node);
-                s_TempEdges.Clear();
-                GetEdges(slot.slotReference, s_TempEdges);
-                foreach (var edge in s_TempEdges)
-                    ConnectNoValidate(node.GetSlotReference(slotId), edge.inputSlot);
+            foreach (var edge in this.GetEdges(slot.slotReference))
+                ConnectNoValidate(newSlot.slotReference, edge.inputSlot);
-                RemoveNodeNoValidate(propertyNode);
-            }
+            RemoveNodeNoValidate(propertyNode);
         }
 
         public void ValidateGraph()
-                ReplacePropertyNodeWithConcreteNode(pNode);
+                ReplacePropertyNodeWithConcreteNodeNoValidate(pNode);
 
             //First validate edges, remove any
             //orphans. This can happen if a user
             }
         }
 
-        public Dictionary<SerializationHelper.TypeSerializationInfo, SerializationHelper.TypeSerializationInfo> GetLegacyTypeRemapping()
+        Dictionary<SerializationHelper.TypeSerializationInfo, SerializationHelper.TypeSerializationInfo> GetLegacyTypeRemapping()
         {
             var result = new Dictionary<SerializationHelper.TypeSerializationInfo, SerializationHelper.TypeSerializationInfo>();
             var viewNode = new SerializationHelper.TypeSerializationInfo
 
         public void ReplaceWith(IGraph other)
         {
-            var otherMG = other as AbstractMaterialGraph;
-            if (otherMG != null)
+            var otherMg = other as AbstractMaterialGraph;
+            if (otherMg == null)
+                throw new ArgumentException("Can only replace with another AbstractMaterialGraph", "other");
+
+            using (var removedPropertiesPooledObject = ListPool<Guid>.GetDisposable())
-                using (var removedPropertiesPooledObject = ListPool<Guid>.GetDisposable())
-                {
-                    var removedPropertyGuids = removedPropertiesPooledObject.value;
-                    foreach (var property in m_Properties)
-                        removedPropertyGuids.Add(property.guid);
-                    foreach (var propertyGuid in removedPropertyGuids)
-                        RemoveShaderPropertyNoValidate(propertyGuid);
-                }
-                foreach (var otherProperty in otherMG.properties)
-                {
-                    if (!properties.Any(p => p.guid == otherProperty.guid))
-                        AddShaderProperty(otherProperty);
-                }
+                var removedPropertyGuids = removedPropertiesPooledObject.value;
+                foreach (var property in m_Properties)
+                    removedPropertyGuids.Add(property.guid);
+                foreach (var propertyGuid in removedPropertyGuids)
+                    RemoveShaderPropertyNoValidate(propertyGuid);
+            }
+            foreach (var otherProperty in otherMg.properties)
+            {
+                if (!properties.Any(p => p.guid == otherProperty.guid))
+                    AddShaderProperty(otherProperty);
             }
 
             other.ValidateGraph();
                 AddEdgeToNodeEdges(edge);
         }
 
-        internal static ShaderGraphRequirements GetRequirements(List<INode> nodes)
-        {
-            NeededCoordinateSpace requiresNormal = nodes.OfType<IMayRequireNormal>().Aggregate(NeededCoordinateSpace.None, (mask, node) => mask | node.RequiresNormal());
-            NeededCoordinateSpace requiresBitangent = nodes.OfType<IMayRequireBitangent>().Aggregate(NeededCoordinateSpace.None, (mask, node) => mask | node.RequiresBitangent());
-            NeededCoordinateSpace requiresTangent = nodes.OfType<IMayRequireTangent>().Aggregate(NeededCoordinateSpace.None, (mask, node) => mask | node.RequiresTangent());
-            NeededCoordinateSpace requiresViewDir = nodes.OfType<IMayRequireViewDirection>().Aggregate(NeededCoordinateSpace.None, (mask, node) => mask | node.RequiresViewDirection());
-            NeededCoordinateSpace requiresPosition = nodes.OfType<IMayRequirePosition>().Aggregate(NeededCoordinateSpace.None, (mask, node) => mask | node.RequiresPosition());
-            bool requiresScreenPosition = nodes.OfType<IMayRequireScreenPosition>().Any(x => x.RequiresScreenPosition());
-            bool requiresVertexColor = nodes.OfType<IMayRequireVertexColor>().Any(x => x.RequiresVertexColor());
-
-            var meshUV = new List<UVChannel>();
-            for (int uvIndex = 0; uvIndex < ShaderGeneratorNames.UVCount; ++uvIndex)
-            {
-                var channel = (UVChannel)uvIndex;
-                if (nodes.OfType<IMayRequireMeshUV>().Any(x => x.RequiresMeshUV(channel)))
-                    meshUV.Add(channel);
-            }
-
-            // if anything needs tangentspace we have make
-            // sure to have our othonormal basis!
-            var compoundSpaces = requiresBitangent | requiresNormal | requiresPosition
-                | requiresTangent | requiresViewDir | requiresPosition
-                | requiresNormal;
-
-            var needsTangentSpace = (compoundSpaces & NeededCoordinateSpace.Tangent) > 0;
-            if (needsTangentSpace)
-            {
-                requiresBitangent |= NeededCoordinateSpace.Object;
-                requiresNormal |= NeededCoordinateSpace.Object;
-                requiresTangent |= NeededCoordinateSpace.Object;
-            }
-
-            var reqs = new ShaderGraphRequirements()
-            {
-                requiresNormal = requiresNormal,
-                requiresBitangent = requiresBitangent,
-                requiresTangent = requiresTangent,
-                requiresViewDir = requiresViewDir,
-                requiresPosition = requiresPosition,
-                requiresScreenPosition = requiresScreenPosition,
-                requiresVertexColor = requiresVertexColor,
-                requiresMeshUVs = meshUV
-            };
-
-            return reqs;
-        }
-
-        public string GetPreviewShader(AbstractMaterialNode node, out PreviewMode previewMode)
-        {
-            List<PropertyCollector.TextureInfo> configuredTextures;
-            FloatShaderProperty outputIdProperty;
-            return GetShader(node, GenerationMode.Preview, string.Format("hidden/preview/{0}", node.GetVariableNameForNode()), out configuredTextures, out previewMode, out outputIdProperty);
-        }
-
-        public string GetUberPreviewShader(Dictionary<Guid, int> ids, out FloatShaderProperty outputIdProperty)
-        {
-            List<PropertyCollector.TextureInfo> configuredTextures;
-            PreviewMode previewMode;
-            return GetShader(null, GenerationMode.Preview, "hidden/preview", out configuredTextures, out previewMode, out outputIdProperty, ids);
-        }
-
-        internal static void GenerateSurfaceDescriptionStruct(ShaderGenerator surfaceDescriptionStruct, List<MaterialSlot> slots, bool isMaster)
-        {
-            surfaceDescriptionStruct.AddShaderChunk("struct SurfaceDescription{", false);
-            surfaceDescriptionStruct.Indent();
-            if (isMaster)
-            {
-                foreach (var slot in slots)
-                    surfaceDescriptionStruct.AddShaderChunk(string.Format("{0} {1};", AbstractMaterialNode.ConvertConcreteSlotValueTypeToString(AbstractMaterialNode.OutputPrecision.@float, slot.concreteValueType), AbstractMaterialNode.GetHLSLSafeName(slot.shaderOutputName)), false);
-                surfaceDescriptionStruct.Deindent();
-            }
-            else
-            {
-                surfaceDescriptionStruct.AddShaderChunk("float4 PreviewOutput;", false);
-            }
-            surfaceDescriptionStruct.Deindent();
-            surfaceDescriptionStruct.AddShaderChunk("};", false);
-        }
-
-        internal static void GenerateApplicationVertexInputs(ShaderGraphRequirements graphRequiements, ShaderGenerator vertexInputs, int vertexInputStartIndex, int maxVertexInputs)
-        {
-            int vertexInputIndex = vertexInputStartIndex;
-
-            vertexInputs.AddShaderChunk("struct GraphVertexInput", false);
-            vertexInputs.AddShaderChunk("{", false);
-            vertexInputs.Indent();
-            vertexInputs.AddShaderChunk("float4 vertex : POSITION;", false);
-            vertexInputs.AddShaderChunk("float3 normal : NORMAL;", false);
-            vertexInputs.AddShaderChunk("float4 tangent : TANGENT;", false);
-
-            if (graphRequiements.requiresVertexColor)
-            {
-                vertexInputs.AddShaderChunk("float4 color : COLOR;", false);
-            }
-
-            foreach (var channel in graphRequiements.requiresMeshUVs.Distinct())
-            {
-                vertexInputs.AddShaderChunk(string.Format("float4 texcoord{0} : TEXCOORD{1};", ((int)channel).ToString(), vertexInputIndex.ToString()), false);
-                vertexInputIndex++;
-            }
-
-            vertexInputs.AddShaderChunk("UNITY_VERTEX_INPUT_INSTANCE_ID", false);
-            vertexInputs.Deindent();
-            vertexInputs.AddShaderChunk("};", false);
-        }
-
-        internal static void GenerateSurfaceDescription(
-            List<INode> activeNodeList,
-            AbstractMaterialNode masterNode,
-            AbstractMaterialGraph graph,
-            ShaderGenerator surfaceDescriptionFunction,
-            ShaderGenerator shaderFunctionVisitor,
-            PropertyCollector shaderProperties,
-            ShaderGraphRequirements requirements,
-            GenerationMode mode,
-            string functionName = "PopulateSurfaceData",
-            string surfaceDescriptionName = "SurfaceDescription",
-            FloatShaderProperty outputIdProperty = null,
-            Dictionary<Guid, int> ids = null,
-            IEnumerable<MaterialSlot> slots = null)
-        {
-            if (graph == null)
-                return;
-
-            surfaceDescriptionFunction.AddShaderChunk(string.Format("{0} {1}(SurfaceInputs IN) {{", surfaceDescriptionName, functionName), false);
-            surfaceDescriptionFunction.Indent();
-            surfaceDescriptionFunction.AddShaderChunk(string.Format("{0} surface = ({0})0;", surfaceDescriptionName), false);
-
-            foreach (CoordinateSpace space in Enum.GetValues(typeof(CoordinateSpace)))
-            {
-                var neededCoordinateSpace = space.ToNeededCoordinateSpace();
-                if ((requirements.requiresNormal & neededCoordinateSpace) > 0)
-                    surfaceDescriptionFunction.AddShaderChunk(string.Format("float3 {0} = IN.{0};", space.ToVariableName(InterpolatorType.Normal)), false);
-                if ((requirements.requiresTangent & neededCoordinateSpace) > 0)
-                    surfaceDescriptionFunction.AddShaderChunk(string.Format("float3 {0} = IN.{0};", space.ToVariableName(InterpolatorType.Tangent)), false);
-                if ((requirements.requiresBitangent & neededCoordinateSpace) > 0)
-                    surfaceDescriptionFunction.AddShaderChunk(string.Format("float3 {0} = IN.{0};", space.ToVariableName(InterpolatorType.BiTangent)), false);
-                if ((requirements.requiresViewDir & neededCoordinateSpace) > 0)
-                    surfaceDescriptionFunction.AddShaderChunk(string.Format("float3 {0} = IN.{0};", space.ToVariableName(InterpolatorType.ViewDirection)), false);
-                if ((requirements.requiresPosition & neededCoordinateSpace) > 0)
-                    surfaceDescriptionFunction.AddShaderChunk(string.Format("float3 {0} = IN.{0};", space.ToVariableName(InterpolatorType.Position)), false);
-            }
-
-            if (requirements.requiresScreenPosition)
-                surfaceDescriptionFunction.AddShaderChunk(string.Format("float4 {0} = IN.{0};", ShaderGeneratorNames.ScreenPosition), false);
-            if (requirements.requiresVertexColor)
-                surfaceDescriptionFunction.AddShaderChunk(string.Format("float4 {0} = IN.{0};", ShaderGeneratorNames.VertexColor), false);
-
-            foreach (var channel in requirements.requiresMeshUVs.Distinct())
-                surfaceDescriptionFunction.AddShaderChunk(string.Format("half4 {0} = IN.{0};", channel.GetUVName()), false);
-
-            graph.CollectShaderProperties(shaderProperties, mode);
-
-            var currentId = -1;
-            foreach (var activeNode in activeNodeList.OfType<AbstractMaterialNode>())
-            {
-                if (activeNode is IGeneratesFunction)
-                    (activeNode as IGeneratesFunction).GenerateNodeFunction(shaderFunctionVisitor, mode);
-                if (activeNode is IGeneratesBodyCode)
-                    (activeNode as IGeneratesBodyCode).GenerateNodeCode(surfaceDescriptionFunction, mode);
-                if (masterNode == null && activeNode.hasPreview)
-                {
-                    var outputSlot = activeNode.GetOutputSlots<MaterialSlot>().FirstOrDefault();
-                    if (outputSlot != null)
-                    {
-                        currentId++;
-                        ids[activeNode.guid] = currentId;
-                        surfaceDescriptionFunction.AddShaderChunk(string.Format("if ({0} == {1}) {{ surface.PreviewOutput = {2}; return surface; }}", outputIdProperty.referenceName, currentId, ShaderGenerator.AdaptNodeOutputForPreview(activeNode, outputSlot.id, activeNode.GetVariableNameForSlot(outputSlot.id))), false);
-                    }
-                }
-
-                activeNode.CollectShaderProperties(shaderProperties, mode);
-            }
-
-            if (masterNode != null)
-            {
-                if (masterNode is IMasterNode)
-                {
-                    var usedSlots = slots ?? masterNode.GetInputSlots<MaterialSlot>();
-                    foreach (var input in usedSlots)
-                    {
-                        var foundEdges = graph.GetEdges(input.slotReference).ToArray();
-                        if (foundEdges.Any())
-                        {
-                            var outputRef = foundEdges[0].outputSlot;
-                            var fromNode = graph.GetNodeFromGuid<AbstractMaterialNode>(outputRef.nodeGuid);
-                            surfaceDescriptionFunction.AddShaderChunk(string.Format("surface.{0} = {1};", AbstractMaterialNode.GetHLSLSafeName(input.shaderOutputName), fromNode.GetVariableNameForSlot(outputRef.slotId)), true);
-                        }
-                        else
-                        {
-                            surfaceDescriptionFunction.AddShaderChunk(string.Format("surface.{0} = {1};", AbstractMaterialNode.GetHLSLSafeName(input.shaderOutputName), input.GetDefaultValue(mode)), true);
-                        }
-                    }
-                }
-                else if (masterNode.hasPreview)
-                {
-                    foreach (var slot in masterNode.GetOutputSlots<MaterialSlot>())
-                        surfaceDescriptionFunction.AddShaderChunk(string.Format("surface.{0} = {1};", AbstractMaterialNode.GetHLSLSafeName(slot.shaderOutputName), masterNode.GetVariableNameForSlot(slot.id)), true);
-                }
-            }
-
-            surfaceDescriptionFunction.AddShaderChunk("return surface;", false);
-            surfaceDescriptionFunction.Deindent();
-            surfaceDescriptionFunction.AddShaderChunk("}", false);
-        }
-
-        static void Visit(List<INode> outputList, Dictionary<Guid, INode> unmarkedNodes, INode node)
-        {
-            if (!unmarkedNodes.ContainsKey(node.guid))
-                return;
-            foreach (var slot in node.GetInputSlots<ISlot>())
-            {
-                foreach (var edge in node.owner.GetEdges(slot.slotReference))
-                {
-                    var inputNode = node.owner.GetNodeFromGuid(edge.outputSlot.nodeGuid);
-                    Visit(outputList, unmarkedNodes, inputNode);
-                }
-            }
-            unmarkedNodes.Remove(node.guid);
-            outputList.Add(node);
-        }
-
-        public string GetShader(AbstractMaterialNode node, GenerationMode mode, string name, out List<PropertyCollector.TextureInfo> configuredTextures, out PreviewMode previewMode, out FloatShaderProperty outputIdProperty, Dictionary<Guid, int> ids = null)
-        {
-            bool isUber = node == null;
-
-            var vertexInputs = new ShaderGenerator();
-            var vertexShader = new ShaderGenerator();
-            var surfaceDescriptionFunction = new ShaderGenerator();
-            var surfaceDescriptionStruct = new ShaderGenerator();
-            var shaderFunctionVisitor = new ShaderGenerator();
-            var surfaceInputs = new ShaderGenerator();
-
-            surfaceInputs.AddShaderChunk("struct SurfaceInputs{", false);
-            surfaceInputs.Indent();
-
-            var activeNodeList = ListPool<INode>.Get();
-            if (isUber)
-            {
-                var unmarkedNodes = GetNodes<INode>().Where(x => !(x is IMasterNode)).ToDictionary(x => x.guid);
-                while (unmarkedNodes.Any())
-                {
-                    var unmarkedNode = unmarkedNodes.FirstOrDefault();
-                    Visit(activeNodeList, unmarkedNodes, unmarkedNode.Value);
-                }
-            }
-            else
-            {
-                NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, node);
-            }
-
-            var requirements = GetRequirements(activeNodeList);
-            GenerateApplicationVertexInputs(requirements, vertexInputs, 0, 8);
-            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresNormal, InterpolatorType.Normal, surfaceInputs);
-            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresTangent, InterpolatorType.Tangent, surfaceInputs);
-            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresBitangent, InterpolatorType.BiTangent, surfaceInputs);
-            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresViewDir, InterpolatorType.ViewDirection, surfaceInputs);
-            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresPosition, InterpolatorType.Position, surfaceInputs);
-
-            if (requirements.requiresVertexColor)
-                surfaceInputs.AddShaderChunk(string.Format("float4 {0};", ShaderGeneratorNames.VertexColor), false);
-
-            if (requirements.requiresScreenPosition)
-                surfaceInputs.AddShaderChunk(string.Format("float4 {0};", ShaderGeneratorNames.ScreenPosition), false);
-
-            previewMode = PreviewMode.Preview3D;
-            if (!isUber)
-            {
-                foreach (var pNode in activeNodeList.OfType<AbstractMaterialNode>())
-                {
-                    if (pNode.previewMode == PreviewMode.Preview3D)
-                    {
-                        previewMode = PreviewMode.Preview3D;
-                        break;
-                    }
-                }
-            }
-
-            foreach (var channel in requirements.requiresMeshUVs.Distinct())
-                surfaceInputs.AddShaderChunk(string.Format("half4 {0};", channel.GetUVName()), false);
-
-            surfaceInputs.Deindent();
-            surfaceInputs.AddShaderChunk("};", false);
-
-            vertexShader.AddShaderChunk("GraphVertexInput PopulateVertexData(GraphVertexInput v){", false);
-            vertexShader.Indent();
-            vertexShader.AddShaderChunk("return v;", false);
-            vertexShader.Deindent();
-            vertexShader.AddShaderChunk("}", false);
-
-            var slots = new List<MaterialSlot>();
-            foreach (var activeNode in isUber ? activeNodeList.Where(n => ((AbstractMaterialNode)n).hasPreview) : ((INode)node).ToEnumerable())
-            {
-                if (activeNode is IMasterNode)
-                    slots.AddRange(activeNode.GetInputSlots<MaterialSlot>());
-                else
-                    slots.AddRange(activeNode.GetOutputSlots<MaterialSlot>());
-            }
-            GenerateSurfaceDescriptionStruct(surfaceDescriptionStruct, slots, !isUber);
-
-            var shaderProperties = new PropertyCollector();
-            outputIdProperty = new FloatShaderProperty
-            {
-                displayName = "OutputId",
-                generatePropertyBlock = false,
-                value = -1
-            };
-            if (isUber)
-                shaderProperties.AddShaderProperty(outputIdProperty);
-
-            GenerateSurfaceDescription(
-                activeNodeList,
-                node,
-                this,
-                surfaceDescriptionFunction,
-                shaderFunctionVisitor,
-                shaderProperties,
-                requirements,
-                mode,
-                outputIdProperty: outputIdProperty,
-                ids: ids);
-
-            var finalShader = new ShaderGenerator();
-            finalShader.AddShaderChunk(string.Format(@"Shader ""{0}""", name), false);
-            finalShader.AddShaderChunk("{", false);
-            finalShader.Indent();
-
-            finalShader.AddShaderChunk("Properties", false);
-            finalShader.AddShaderChunk("{", false);
-            finalShader.Indent();
-            finalShader.AddShaderChunk(shaderProperties.GetPropertiesBlock(2), false);
-            finalShader.Deindent();
-            finalShader.AddShaderChunk("}", false);
-
-            finalShader.AddShaderChunk("CGINCLUDE", false);
-            finalShader.AddShaderChunk("#include \"UnityCG.cginc\"", false);
-            finalShader.AddShaderChunk(shaderFunctionVisitor.GetShaderString(2), false);
-            finalShader.AddShaderChunk(vertexInputs.GetShaderString(2), false);
-            finalShader.AddShaderChunk(surfaceInputs.GetShaderString(2), false);
-            finalShader.AddShaderChunk(surfaceDescriptionStruct.GetShaderString(2), false);
-            finalShader.AddShaderChunk(shaderProperties.GetPropertiesDeclaration(2), false);
-            finalShader.AddShaderChunk(vertexShader.GetShaderString(2), false);
-            finalShader.AddShaderChunk(surfaceDescriptionFunction.GetShaderString(2), false);
-            finalShader.AddShaderChunk("ENDCG", false);
-
-            finalShader.AddShaderChunk(ShaderGenerator.GetPreviewSubShader(node, requirements), false);
-
-            ListPool<INode>.Release(activeNodeList);
-
-            finalShader.Deindent();
-            finalShader.AddShaderChunk("}", false);
-            configuredTextures = shaderProperties.GetConfiguredTexutres();
-            return finalShader.GetShaderString(0);
-        }
-
         public void OnEnable()
         {
             foreach (var node in GetNodes<INode>().OfType<IOnAssetEnabled>())
         }
     }
-    
+
     [Serializable]
     public class InspectorPreviewData
     {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/AbstractShaderProperty.cs

 using System;
+using UnityEditor.Graphing;
 using UnityEngine;
 
 namespace UnityEditor.ShaderGraph
         }
 
         public abstract PreviewProperty GetPreviewMaterialProperty();
+        public abstract INode ToConcreteNode();
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/ColorShaderProperty.cs

 using System;
 using System.Text;
+using UnityEditor.Graphing;
 using UnityEngine;
 
 namespace UnityEditor.ShaderGraph
                 propType = PropertyType.Color,
                 colorValue = value
             };
+        }
+
+        public override INode ToConcreteNode()
+        {
+            return new ColorNode { color = value };
         }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/CubemapShaderProperty.cs

 using System;
 using System.Text;
+using UnityEditor.Graphing;
 using UnityEngine;
 
 namespace UnityEditor.ShaderGraph
                 propType = PropertyType.Cubemap,
                 cubemapValue = value.cubemap
             };
+        }
+
+        public override INode ToConcreteNode()
+        {
+            return new CubemapAssetNode { cubemap = value.cubemap };
         }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/FloatShaderProperty.cs

 using System;
 using System.Text;
+using UnityEditor.Graphing;
 using UnityEngine;
 
 namespace UnityEditor.ShaderGraph
                 propType = PropertyType.Float,
                 floatValue = value
             };
+        }
+
+        public override INode ToConcreteNode()
+        {
+            return new Vector1Node { value = value };
         }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/IShaderProperty.cs

 using System;
+using UnityEditor.Graphing;
 using UnityEngine;
 
 namespace UnityEditor.ShaderGraph
         string GetPropertyDeclarationString();
         string GetInlinePropertyDeclarationString();
         PreviewProperty GetPreviewMaterialProperty();
+        INode ToConcreteNode();
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/SamplerStateShaderProperty.cs

 using System;
+using UnityEditor.Graphing;
 using UnityEngine;
 
 namespace UnityEditor.ShaderGraph
         public override PreviewProperty GetPreviewMaterialProperty()
         {
             return default(PreviewProperty);
+        }
+
+        public override INode ToConcreteNode()
+        {
+            return new SamplerStateNode();
         }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/TextureShaderProperty.cs

 using System;
 using System.Text;
+using UnityEditor.Graphing;
 using UnityEngine;
 
 namespace UnityEditor.ShaderGraph
                 propType = PropertyType.Texture,
                 textureValue = value.texture
             };
+        }
+
+        public override INode ToConcreteNode()
+        {
+            return new Texture2DAssetNode { texture = value.texture };
         }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/Vector2ShaderProperty.cs

 using System;
+using UnityEditor.Graphing;
 using UnityEngine;
 
 namespace UnityEditor.ShaderGraph
                 propType = PropertyType.Vector2,
                 vector4Value = value
             };
+        }
+
+        public override INode ToConcreteNode()
+        {
+            return new Vector2Node { value = value };
         }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/Vector3ShaderProperty.cs

 using System;
+using UnityEditor.Graphing;
 using UnityEngine;
 
 namespace UnityEditor.ShaderGraph
                 propType = PropertyType.Vector3,
                 vector4Value = value
             };
+        }
+
+        public override INode ToConcreteNode()
+        {
+            return new Vector3Node { value = value };
         }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/Vector4ShaderProperty.cs

 using System;
+using UnityEditor.Graphing;
 using UnityEngine;
 
 namespace UnityEditor.ShaderGraph
                 propType = PropertyType.Vector4,
                 vector4Value = value
             };
+        }
+
+        public override INode ToConcreteNode()
+        {
+            return new Vector4Node { value = value };
         }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/LightweightPipeline/LightWeightPBRSubShader.cs

             var activeNodeList = ListPool<INode>.Get();
             NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, masterNode, NodeUtils.IncludeSelf.Include, pass.PixelShaderSlots);
 
-            var requirements = AbstractMaterialGraph.GetRequirements(activeNodeList);
+            var requirements = GraphUtil.GetRequirements(activeNodeList);
 
             var modelRequiements = ShaderGraphRequirements.none;
             modelRequiements.requiresNormal |= NeededCoordinateSpace.World;
             var slots = new List<MaterialSlot>();
             foreach (var id in pass.PixelShaderSlots)
                 slots.Add(masterNode.FindSlot<MaterialSlot>(id));
-            AbstractMaterialGraph.GenerateSurfaceDescriptionStruct(surfaceDescriptionStruct, slots, true);
+            GraphUtil.GenerateSurfaceDescriptionStruct(surfaceDescriptionStruct, slots, true);
-            AbstractMaterialGraph.GenerateSurfaceDescription(
+            GraphUtil.GenerateSurfaceDescription(
                 activeNodeList,
                 masterNode,
                 masterNode.owner as AbstractMaterialGraph,

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/LightweightPipeline/LightWeightUnlitSubShader.cs

             var activeNodeList = ListPool<INode>.Get();
             NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, masterNode, NodeUtils.IncludeSelf.Include, pass.PixelShaderSlots);
 
-            var requirements = AbstractMaterialGraph.GetRequirements(activeNodeList);
-            AbstractMaterialGraph.GenerateApplicationVertexInputs(requirements, vertexInputs, 0, 8);
+            var requirements = GraphUtil.GetRequirements(activeNodeList);
+            GraphUtil.GenerateApplicationVertexInputs(requirements, vertexInputs, 0, 8);
             ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresNormal, InterpolatorType.Normal, surfaceInputs);
             ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresTangent, InterpolatorType.Tangent, surfaceInputs);
             ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresBitangent, InterpolatorType.BiTangent, surfaceInputs);
                 if (slot != null)
                     slots.Add(slot);
             }
-            AbstractMaterialGraph.GenerateSurfaceDescriptionStruct(surfaceDescriptionStruct, slots, true);
+            GraphUtil.GenerateSurfaceDescriptionStruct(surfaceDescriptionStruct, slots, true);
-            AbstractMaterialGraph.GenerateSurfaceDescription(
+            GraphUtil.GenerateSurfaceDescription(
                 activeNodeList,
                 masterNode,
                 masterNode.owner as AbstractMaterialGraph,

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Util/GraphUtil.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor.Graphing;
+using UnityEditor.Graphing.Util;
+
+namespace UnityEditor.ShaderGraph
+{
+    static class GraphUtil
+    {
+        internal static ShaderGraphRequirements GetRequirements(List<INode> nodes)
+        {
+            NeededCoordinateSpace requiresNormal = nodes.OfType<IMayRequireNormal>().Aggregate(NeededCoordinateSpace.None, (mask, node) => mask | node.RequiresNormal());
+            NeededCoordinateSpace requiresBitangent = nodes.OfType<IMayRequireBitangent>().Aggregate(NeededCoordinateSpace.None, (mask, node) => mask | node.RequiresBitangent());
+            NeededCoordinateSpace requiresTangent = nodes.OfType<IMayRequireTangent>().Aggregate(NeededCoordinateSpace.None, (mask, node) => mask | node.RequiresTangent());
+            NeededCoordinateSpace requiresViewDir = nodes.OfType<IMayRequireViewDirection>().Aggregate(NeededCoordinateSpace.None, (mask, node) => mask | node.RequiresViewDirection());
+            NeededCoordinateSpace requiresPosition = nodes.OfType<IMayRequirePosition>().Aggregate(NeededCoordinateSpace.None, (mask, node) => mask | node.RequiresPosition());
+            bool requiresScreenPosition = nodes.OfType<IMayRequireScreenPosition>().Any(x => x.RequiresScreenPosition());
+            bool requiresVertexColor = nodes.OfType<IMayRequireVertexColor>().Any(x => x.RequiresVertexColor());
+
+            var meshUV = new List<UVChannel>();
+            for (int uvIndex = 0; uvIndex < ShaderGeneratorNames.UVCount; ++uvIndex)
+            {
+                var channel = (UVChannel)uvIndex;
+                if (nodes.OfType<IMayRequireMeshUV>().Any(x => x.RequiresMeshUV(channel)))
+                    meshUV.Add(channel);
+            }
+
+            // if anything needs tangentspace we have make
+            // sure to have our othonormal basis!
+            var compoundSpaces = requiresBitangent | requiresNormal | requiresPosition
+                | requiresTangent | requiresViewDir | requiresPosition
+                | requiresNormal;
+
+            var needsTangentSpace = (compoundSpaces & NeededCoordinateSpace.Tangent) > 0;
+            if (needsTangentSpace)
+            {
+                requiresBitangent |= NeededCoordinateSpace.Object;
+                requiresNormal |= NeededCoordinateSpace.Object;
+                requiresTangent |= NeededCoordinateSpace.Object;
+            }
+
+            var reqs = new ShaderGraphRequirements()
+            {
+                requiresNormal = requiresNormal,
+                requiresBitangent = requiresBitangent,
+                requiresTangent = requiresTangent,
+                requiresViewDir = requiresViewDir,
+                requiresPosition = requiresPosition,
+                requiresScreenPosition = requiresScreenPosition,
+                requiresVertexColor = requiresVertexColor,
+                requiresMeshUVs = meshUV
+            };
+
+            return reqs;
+        }
+
+        internal static void GenerateApplicationVertexInputs(ShaderGraphRequirements graphRequiements, ShaderGenerator vertexInputs, int vertexInputStartIndex, int maxVertexInputs)
+        {
+            int vertexInputIndex = vertexInputStartIndex;
+
+            vertexInputs.AddShaderChunk("struct GraphVertexInput", false);
+            vertexInputs.AddShaderChunk("{", false);
+            vertexInputs.Indent();
+            vertexInputs.AddShaderChunk("float4 vertex : POSITION;", false);
+            vertexInputs.AddShaderChunk("float3 normal : NORMAL;", false);
+            vertexInputs.AddShaderChunk("float4 tangent : TANGENT;", false);
+
+            if (graphRequiements.requiresVertexColor)
+            {
+                vertexInputs.AddShaderChunk("float4 color : COLOR;", false);
+            }
+
+            foreach (var channel in graphRequiements.requiresMeshUVs.Distinct())
+            {
+                vertexInputs.AddShaderChunk(String.Format("float4 texcoord{0} : TEXCOORD{1};", ((int)channel).ToString(), vertexInputIndex.ToString()), false);
+                vertexInputIndex++;
+            }
+
+            vertexInputs.AddShaderChunk("UNITY_VERTEX_INPUT_INSTANCE_ID", false);
+            vertexInputs.Deindent();
+            vertexInputs.AddShaderChunk("};", false);
+        }
+
+        static void Visit(List<INode> outputList, Dictionary<Guid, INode> unmarkedNodes, INode node)
+        {
+            if (!unmarkedNodes.ContainsKey(node.guid))
+                return;
+            foreach (var slot in node.GetInputSlots<ISlot>())
+            {
+                foreach (var edge in node.owner.GetEdges(slot.slotReference))
+                {
+                    var inputNode = node.owner.GetNodeFromGuid(edge.outputSlot.nodeGuid);
+                    Visit(outputList, unmarkedNodes, inputNode);
+                }
+            }
+            unmarkedNodes.Remove(node.guid);
+            outputList.Add(node);
+        }
+
+        public static string GetShader(this AbstractMaterialGraph graph, AbstractMaterialNode node, GenerationMode mode, string name, out List<PropertyCollector.TextureInfo> configuredTextures, out PreviewMode previewMode, out FloatShaderProperty outputIdProperty, Dictionary<Guid, int> ids = null)
+        {
+            bool isUber = node == null;
+
+            var vertexInputs = new ShaderGenerator();
+            var vertexShader = new ShaderGenerator();
+            var surfaceDescriptionFunction = new ShaderGenerator();
+            var surfaceDescriptionStruct = new ShaderGenerator();
+            var shaderFunctionVisitor = new ShaderGenerator();
+            var surfaceInputs = new ShaderGenerator();
+
+            surfaceInputs.AddShaderChunk("struct SurfaceInputs{", false);
+            surfaceInputs.Indent();
+
+            var activeNodeList = ListPool<INode>.Get();
+            if (isUber)
+            {
+                var unmarkedNodes = graph.GetNodes<INode>().Where(x => !(x is IMasterNode)).ToDictionary(x => x.guid);
+                while (unmarkedNodes.Any())
+                {
+                    var unmarkedNode = unmarkedNodes.FirstOrDefault();
+                    Visit(activeNodeList, unmarkedNodes, unmarkedNode.Value);
+                }
+            }
+            else
+            {
+                NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, node);
+            }
+
+            var requirements = GraphUtil.GetRequirements(activeNodeList);
+            GraphUtil.GenerateApplicationVertexInputs(requirements, vertexInputs, 0, 8);
+            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresNormal, InterpolatorType.Normal, surfaceInputs);
+            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresTangent, InterpolatorType.Tangent, surfaceInputs);
+            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresBitangent, InterpolatorType.BiTangent, surfaceInputs);
+            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresViewDir, InterpolatorType.ViewDirection, surfaceInputs);
+            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresPosition, InterpolatorType.Position, surfaceInputs);
+
+            if (requirements.requiresVertexColor)
+                surfaceInputs.AddShaderChunk(String.Format("float4 {0};", ShaderGeneratorNames.VertexColor), false);
+
+            if (requirements.requiresScreenPosition)
+                surfaceInputs.AddShaderChunk(String.Format("float4 {0};", ShaderGeneratorNames.ScreenPosition), false);
+
+            previewMode = PreviewMode.Preview3D;
+            if (!isUber)
+            {
+                foreach (var pNode in activeNodeList.OfType<AbstractMaterialNode>())
+                {
+                    if (pNode.previewMode == PreviewMode.Preview3D)
+                    {
+                        previewMode = PreviewMode.Preview3D;
+                        break;
+                    }
+                }
+            }
+
+            foreach (var channel in requirements.requiresMeshUVs.Distinct())
+                surfaceInputs.AddShaderChunk(String.Format("half4 {0};", channel.GetUVName()), false);
+
+            surfaceInputs.Deindent();
+            surfaceInputs.AddShaderChunk("};", false);
+
+            vertexShader.AddShaderChunk("GraphVertexInput PopulateVertexData(GraphVertexInput v){", false);
+            vertexShader.Indent();
+            vertexShader.AddShaderChunk("return v;", false);
+            vertexShader.Deindent();
+            vertexShader.AddShaderChunk("}", false);
+
+            var slots = new List<MaterialSlot>();
+            foreach (var activeNode in isUber ? activeNodeList.Where(n => ((AbstractMaterialNode)n).hasPreview) : ((INode)node).ToEnumerable())
+            {
+                if (activeNode is IMasterNode)
+                    slots.AddRange(activeNode.GetInputSlots<MaterialSlot>());
+                else
+                    slots.AddRange(activeNode.GetOutputSlots<MaterialSlot>());
+            }
+            GenerateSurfaceDescriptionStruct(surfaceDescriptionStruct, slots, !isUber);
+
+            var shaderProperties = new PropertyCollector();
+            outputIdProperty = new FloatShaderProperty
+            {
+                displayName = "OutputId",
+                generatePropertyBlock = false,
+                value = -1
+            };
+            if (isUber)
+                shaderProperties.AddShaderProperty(outputIdProperty);
+
+            GenerateSurfaceDescription(
+                activeNodeList,
+                node,
+                graph,
+                surfaceDescriptionFunction,
+                shaderFunctionVisitor,
+                shaderProperties,
+                requirements,
+                mode,
+                outputIdProperty: outputIdProperty,
+                ids: ids);
+
+            var finalShader = new ShaderGenerator();
+            finalShader.AddShaderChunk(String.Format(@"Shader ""{0}""", name), false);
+            finalShader.AddShaderChunk("{", false);
+            finalShader.Indent();
+
+            finalShader.AddShaderChunk("Properties", false);
+            finalShader.AddShaderChunk("{", false);
+            finalShader.Indent();
+            finalShader.AddShaderChunk(shaderProperties.GetPropertiesBlock(2), false);
+            finalShader.Deindent();
+            finalShader.AddShaderChunk("}", false);
+
+            finalShader.AddShaderChunk("CGINCLUDE", false);
+            finalShader.AddShaderChunk("#include \"UnityCG.cginc\"", false);
+            finalShader.AddShaderChunk(shaderFunctionVisitor.GetShaderString(2), false);
+            finalShader.AddShaderChunk(vertexInputs.GetShaderString(2), false);
+            finalShader.AddShaderChunk(surfaceInputs.GetShaderString(2), false);
+            finalShader.AddShaderChunk(surfaceDescriptionStruct.GetShaderString(2), false);
+            finalShader.AddShaderChunk(shaderProperties.GetPropertiesDeclaration(2), false);
+            finalShader.AddShaderChunk(vertexShader.GetShaderString(2), false);
+            finalShader.AddShaderChunk(surfaceDescriptionFunction.GetShaderString(2), false);
+            finalShader.AddShaderChunk("ENDCG", false);
+
+            finalShader.AddShaderChunk(ShaderGenerator.GetPreviewSubShader(node, requirements), false);
+
+            ListPool<INode>.Release(activeNodeList);
+
+            finalShader.Deindent();
+            finalShader.AddShaderChunk("}", false);
+            configuredTextures = shaderProperties.GetConfiguredTexutres();
+            return finalShader.GetShaderString(0);
+        }
+
+        internal static void GenerateSurfaceDescriptionStruct(ShaderGenerator surfaceDescriptionStruct, List<MaterialSlot> slots, bool isMaster)
+        {
+            surfaceDescriptionStruct.AddShaderChunk("struct SurfaceDescription{", false);
+            surfaceDescriptionStruct.Indent();
+            if (isMaster)
+            {
+                foreach (var slot in slots)
+                    surfaceDescriptionStruct.AddShaderChunk(String.Format("{0} {1};", AbstractMaterialNode.ConvertConcreteSlotValueTypeToString(AbstractMaterialNode.OutputPrecision.@float, slot.concreteValueType), AbstractMaterialNode.GetHLSLSafeName(slot.shaderOutputName)), false);
+                surfaceDescriptionStruct.Deindent();
+            }
+            else
+            {
+                surfaceDescriptionStruct.AddShaderChunk("float4 PreviewOutput;", false);
+            }
+            surfaceDescriptionStruct.Deindent();
+            surfaceDescriptionStruct.AddShaderChunk("};", false);
+        }
+
+        internal static void GenerateSurfaceDescription(
+            List<INode> activeNodeList,
+            AbstractMaterialNode masterNode,
+            AbstractMaterialGraph graph,
+            ShaderGenerator surfaceDescriptionFunction,
+            ShaderGenerator shaderFunctionVisitor,
+            PropertyCollector shaderProperties,
+            ShaderGraphRequirements requirements,
+            GenerationMode mode,
+            string functionName = "PopulateSurfaceData",
+            string surfaceDescriptionName = "SurfaceDescription",
+            FloatShaderProperty outputIdProperty = null,
+            Dictionary<Guid, int> ids = null,
+            IEnumerable<MaterialSlot> slots = null)
+        {
+            if (graph == null)
+                return;
+
+            surfaceDescriptionFunction.AddShaderChunk(String.Format("{0} {1}(SurfaceInputs IN) {{", surfaceDescriptionName, functionName), false);
+            surfaceDescriptionFunction.Indent();
+            surfaceDescriptionFunction.AddShaderChunk(String.Format("{0} surface = ({0})0;", surfaceDescriptionName), false);
+
+            foreach (CoordinateSpace space in Enum.GetValues(typeof(CoordinateSpace)))
+            {
+                var neededCoordinateSpace = space.ToNeededCoordinateSpace();
+                if ((requirements.requiresNormal & neededCoordinateSpace) > 0)
+                    surfaceDescriptionFunction.AddShaderChunk(String.Format("float3 {0} = IN.{0};", space.ToVariableName(InterpolatorType.Normal)), false);
+                if ((requirements.requiresTangent & neededCoordinateSpace) > 0)
+                    surfaceDescriptionFunction.AddShaderChunk(String.Format("float3 {0} = IN.{0};", space.ToVariableName(InterpolatorType.Tangent)), false);
+                if ((requirements.requiresBitangent & neededCoordinateSpace) > 0)
+                    surfaceDescriptionFunction.AddShaderChunk(String.Format("float3 {0} = IN.{0};", space.ToVariableName(InterpolatorType.BiTangent)), false);
+                if ((requirements.requiresViewDir & neededCoordinateSpace) > 0)
+                    surfaceDescriptionFunction.AddShaderChunk(String.Format("float3 {0} = IN.{0};", space.ToVariableName(InterpolatorType.ViewDirection)), false);
+                if ((requirements.requiresPosition & neededCoordinateSpace) > 0)
+                    surfaceDescriptionFunction.AddShaderChunk(String.Format("float3 {0} = IN.{0};", space.ToVariableName(InterpolatorType.Position)), false);
+            }
+
+            if (requirements.requiresScreenPosition)
+                surfaceDescriptionFunction.AddShaderChunk(String.Format("float4 {0} = IN.{0};", ShaderGeneratorNames.ScreenPosition), false);
+            if (requirements.requiresVertexColor)
+                surfaceDescriptionFunction.AddShaderChunk(String.Format("float4 {0} = IN.{0};", ShaderGeneratorNames.VertexColor), false);
+
+            foreach (var channel in requirements.requiresMeshUVs.Distinct())
+                surfaceDescriptionFunction.AddShaderChunk(String.Format("half4 {0} = IN.{0};", channel.GetUVName()), false);
+
+            graph.CollectShaderProperties(shaderProperties, mode);
+
+            var currentId = -1;
+            foreach (var activeNode in activeNodeList.OfType<AbstractMaterialNode>())
+            {
+                if (activeNode is IGeneratesFunction)
+                    (activeNode as IGeneratesFunction).GenerateNodeFunction(shaderFunctionVisitor, mode);
+                if (activeNode is IGeneratesBodyCode)
+                    (activeNode as IGeneratesBodyCode).GenerateNodeCode(surfaceDescriptionFunction, mode);
+                if (masterNode == null && activeNode.hasPreview)
+                {
+                    var outputSlot = activeNode.GetOutputSlots<MaterialSlot>().FirstOrDefault();
+                    if (outputSlot != null)
+                    {
+                        currentId++;
+                        ids[activeNode.guid] = currentId;
+                        surfaceDescriptionFunction.AddShaderChunk(String.Format("if ({0} == {1}) {{ surface.PreviewOutput = {2}; return surface; }}", outputIdProperty.referenceName, currentId, ShaderGenerator.AdaptNodeOutputForPreview(activeNode, outputSlot.id, activeNode.GetVariableNameForSlot(outputSlot.id))), false);
+                    }
+                }
+
+                activeNode.CollectShaderProperties(shaderProperties, mode);
+            }
+
+            if (masterNode != null)
+            {
+                if (masterNode is IMasterNode)
+                {
+                    var usedSlots = slots ?? masterNode.GetInputSlots<MaterialSlot>();
+                    foreach (var input in usedSlots)
+                    {
+                        var foundEdges = graph.GetEdges(input.slotReference).ToArray();
+                        if (foundEdges.Any())
+                        {
+                            var outputRef = foundEdges[0].outputSlot;
+                            var fromNode = graph.GetNodeFromGuid<AbstractMaterialNode>(outputRef.nodeGuid);
+                            surfaceDescriptionFunction.AddShaderChunk(String.Format("surface.{0} = {1};", AbstractMaterialNode.GetHLSLSafeName(input.shaderOutputName), fromNode.GetVariableNameForSlot(outputRef.slotId)), true);
+                        }
+                        else
+                        {
+                            surfaceDescriptionFunction.AddShaderChunk(String.Format("surface.{0} = {1};", AbstractMaterialNode.GetHLSLSafeName(input.shaderOutputName), input.GetDefaultValue(mode)), true);
+                        }
+                    }
+                }
+                else if (masterNode.hasPreview)
+                {
+                    foreach (var slot in masterNode.GetOutputSlots<MaterialSlot>())
+                        surfaceDescriptionFunction.AddShaderChunk(String.Format("surface.{0} = {1};", AbstractMaterialNode.GetHLSLSafeName(slot.shaderOutputName), masterNode.GetVariableNameForSlot(slot.id)), true);
+                }
+            }
+
+            surfaceDescriptionFunction.AddShaderChunk("return surface;", false);
+            surfaceDescriptionFunction.Deindent();
+            surfaceDescriptionFunction.AddShaderChunk("}", false);
+        }
+
+        public static string GetPreviewShader(this AbstractMaterialGraph graph, AbstractMaterialNode node, out PreviewMode previewMode)
+        {
+            List<PropertyCollector.TextureInfo> configuredTextures;
+            FloatShaderProperty outputIdProperty;
+            return graph.GetShader(node, GenerationMode.Preview, string.Format("hidden/preview/{0}", node.GetVariableNameForNode()), out configuredTextures, out previewMode, out outputIdProperty);
+        }
+
+        public static string GetUberPreviewShader(this AbstractMaterialGraph graph, Dictionary<Guid, int> ids, out FloatShaderProperty outputIdProperty)
+        {
+            List<PropertyCollector.TextureInfo> configuredTextures;
+            PreviewMode previewMode;
+            return graph.GetShader(null, GenerationMode.Preview, "hidden/preview", out configuredTextures, out previewMode, out outputIdProperty, ids);
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Util/GraphUtil.cs.meta

+fileFormatVersion: 2
+guid: 130a64d32c054c5fb51b1e5e13f93fc2
+timeCreated: 1513590591