Merge branch 'RemapAndSubshader'

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

             Assert.AreEqual(3, result.Count);
 
             result.Clear();
-            NodeUtils.DepthFirstCollectNodesFromNode(result, inputNode, TestableNode.Input0);
+            NodeUtils.DepthFirstCollectNodesFromNode(result, inputNode);
-            NodeUtils.DepthFirstCollectNodesFromNode(result, inputNode, TestableNode.Input1);
+            NodeUtils.DepthFirstCollectNodesFromNode(result, inputNode);
-            NodeUtils.DepthFirstCollectNodesFromNode(result, inputNode, TestableNode.Input0, NodeUtils.IncludeSelf.Exclude);
+            NodeUtils.DepthFirstCollectNodesFromNode(result, inputNode, NodeUtils.IncludeSelf.Exclude);
-            NodeUtils.DepthFirstCollectNodesFromNode(result, inputNode, TestableNode.Input1, NodeUtils.IncludeSelf.Exclude);
+            NodeUtils.DepthFirstCollectNodesFromNode(result, inputNode, NodeUtils.IncludeSelf.Exclude);
             Assert.AreEqual(0, result.Count);
 
             result.Clear();

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

 using System;
 using System.Collections.Generic;
 using System.Linq;
+using UnityEngine.MaterialGraph;
 
 namespace UnityEngine.Graphing
 {
             Exclude
         }
 
-        public static void DepthFirstCollectNodesFromNode(List<INode> nodeList, INode node, int? slotId = null, IncludeSelf includeSelf = IncludeSelf.Include)
-        {
-            DepthFirstCollectNodesFromNodeSlotList(nodeList, node, slotId.HasValue ? new List<int>() { slotId.Value } : null, includeSelf);
-        }
-
-        public static void DepthFirstCollectNodesFromNodeSlotList(List<INode> nodeList, INode node, List<int> slotId = null, IncludeSelf includeSelf = IncludeSelf.Include)
+        public static void DepthFirstCollectNodesFromNode(List<INode> nodeList, INode node, IncludeSelf includeSelf = IncludeSelf.Include)
-            // allready added this node
+            // already added this node
-            // if we have a slot passed in but can not find it on the node abort
-            if (slotId != null && node.GetInputSlots<ISlot>().All(x => !slotId.Contains(x.id)))
+            var remapper = node as INodeGroupRemapper;
+            if (remapper != null)
+            {
+                remapper.DepthFirstCollectNodesFromNodeSlotList(nodeList, includeSelf);
-
-            var validSlots = ListPool<int>.Get();
-            if (slotId != null)
-                slotId.ForEach(x => validSlots.Add(x));
-            else
-                validSlots.AddRange(node.GetInputSlots<ISlot>().Select(x => x.id));
-
-            foreach (var slot in validSlots)
+            }
+            
+            foreach (var slot in node.GetInputSlots<ISlot>().Select(x => x.id))
-                    DepthFirstCollectNodesFromNodeSlotList(nodeList, outputNode);
+                    DepthFirstCollectNodesFromNode(nodeList, outputNode);
-            ListPool<int>.Release(validSlots);
         }
 
         public static void CollectNodesNodeFeedsInto(List<INode> nodeList, INode node, IncludeSelf includeSelf = IncludeSelf.Include)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/AssetCallbacks/CreateShaderSubGraph.cs

+using System.IO;
 using System.IO;
 using UnityEditor.ProjectWindowCallback;
 using UnityEngine.MaterialGraph;

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/DrawData/MaterialGraphDataSource.cs

             AddTypeMapping(typeof(Vector3Node), typeof(Vector3NodeDrawData));
             AddTypeMapping(typeof(Vector4Node), typeof(Vector4NodeDrawData));
             AddTypeMapping(typeof(SubGraphNode), typeof(SubgraphNodeDrawData));
+            AddTypeMapping(typeof(RemapMasterNode), typeof(RemapMasterNodeDrawData));
+            AddTypeMapping(typeof(MasterRemapInputNode), typeof(RemapInputNodeDrawData));
+            AddTypeMapping(typeof(AbstractSurfaceMasterNode), typeof(SurfaceMasterDrawData));
 			AddTypeMapping(typeof(EdgeDrawData), typeof(Edge));
         }
     }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/DrawData/NodePreviewDrawData.cs

         protected virtual string GetPreviewShaderString()
         {
             // TODO: this is a workaround right now.
-            if (m_Node is AbstractMasterNode)
+            if (m_Node is IMasterNode)
-                var localNode = (AbstractMasterNode)m_Node;
+                var localNode = (IMasterNode)m_Node;
-                var resultShader =  ((AbstractMasterNode) m_Node).GetShader(GenerationMode.Preview, out defaultTextures);
+                var resultShader =  ((IMasterNode) m_Node).GetFullShader(GenerationMode.Preview, out defaultTextures);
                 m_GeneratedShaderMode = PreviewMode.Preview3D;
                 return resultShader;
             }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Templates/shader.template

 ${ShaderPropertiesHeader}
 	}	
 	
-	SubShader 
-	{
-${Tags}
-${Blending}
-${Culling}
-${ZTest}
-${ZWrite}
-
-		LOD 200
-		
-		CGPROGRAM
-		#pragma target 3.0
-		#pragma surface surf ${LightingFunctionName} ${VertexShaderDecl}
-		#pragma glsl
-		#pragma debug
-
-${ShaderFunctions}
-${ShaderPropertyUsages}
+${SubShader}
-		struct Input 
-		{
-${ShaderInputs}
-		};
-
-		void vert (inout appdata_full v, out Input o)
-		{
-			UNITY_INITIALIZE_OUTPUT(Input,o);
-${VertexShaderBody}
-		}
-	  
-		void surf (Input IN, inout ${SurfaceOutputStructureName} o) 
-		{
-${PixelShaderBody}
-		}
-		ENDCG
-	} 
 	FallBack "Diffuse"
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/IntegrationTests/ShaderGenerationTest.cs

 
             // Generate the shader
             List<PropertyGenerator.TextureInfo> configuredTextures;
-            var shaderString = materialGraph.masterNode.GetShader(GenerationMode.ForReals, out configuredTextures);
+            var shaderString = materialGraph.masterNode.GetFullShader(GenerationMode.ForReals, out configuredTextures);
             m_Shader = ShaderUtil.CreateShaderAsset(shaderString);
             m_Shader.hideFlags = HideFlags.HideAndDontSave;
             Assert.IsNotNull(m_Shader, "Shader Generation Failed");

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Graphs/MaterialGraphAsset.cs

 
             var path = "Assets/GraphTemp.shader";
             List<PropertyGenerator.TextureInfo> configuredTextures;
-            var shaderString = m_MaterialGraph.masterNode.GetShader(GenerationMode.ForReals, out configuredTextures);
+            var shaderString = m_MaterialGraph.masterNode.GetFullShader(GenerationMode.ForReals, out configuredTextures);
             File.WriteAllText(path, shaderString);
             AssetDatabase.ImportAsset(path);
 
 
             var imported = shaderImporter.GetShader();
 
-	        if (m_GeneratedShader == null)
-	        {
-		        m_GeneratedShader = Instantiate(imported);
-	        }
-	        else
-	        {
-		        var oldID = m_GeneratedShader.GetInstanceID();
-		        DestroyImmediate(m_GeneratedShader,  true);
-		        var newAsset = Instantiate(imported, oldID);
-		        m_GeneratedShader = newAsset;
-	        }
-	        AssetDatabase.AddObjectToAsset(m_GeneratedShader, this);
+            if (m_GeneratedShader == null)
+            {
+                m_GeneratedShader = Instantiate(imported);
+                AssetDatabase.AddObjectToAsset(m_GeneratedShader, this);
+            }
+            else
+            {
+                AssetDatabase.CopyAsset(imported, m_GeneratedShader);
+                DestroyImmediate(imported, true);
+            }
-            
+
             return true;
         }
 #endif

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Interfaces/IMasterNode.cs

 {
     public interface IMasterNode : INode
     {
-        string GetShader(
+        string GetFullShader(
+
+        string GetSubShader(GenerationMode mode, PropertyGenerator shaderPropertiesVisitor);
 
         string GetVariableNameForNode();
     }

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

         {
             get { return true; }
         }
+        
+        public override bool allowedInSubGraph
+        {
+            get { return false; }
+        }
-        public abstract string GetShader(GenerationMode mode, out List<PropertyGenerator.TextureInfo> configuredTextures);
+        public abstract string GetFullShader(GenerationMode mode, out List<PropertyGenerator.TextureInfo> configuredTextures);
+        public abstract string GetSubShader(GenerationMode mode, PropertyGenerator shaderPropertiesVisitor);
     }
 }

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

             get { return PreviewMode.Preview2D; }
         }
 
+        public virtual bool allowedInSubGraph
+        {
+            get { return true; }
+        }
+
+        public virtual bool allowedInRemapGraph
+        {
+            get { return true; }
+        }
+
         protected virtual bool generateDefaultInputs
         {
             get { return true; }

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

 
         [SerializeField]
         private ExposedState m_Exposed = ExposedState.NotExposed;
-
+        
         public ExposedState exposedState
         {
             get

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SubGraph/SubGraph.cs

                 Debug.LogWarning("Attempting to add second SubGraphOutputNode to SubGraph. This is not allowed.");
                 return;
             }
+
+            var materialNode = node as AbstractMaterialNode;
+            if (materialNode != null)
+            {
+                var amn = materialNode;
+                if (!amn.allowedInSubGraph)
+                {
+                    Debug.LogWarningFormat("Attempting to add {0} to Sub Graph. This is not allowed.", amn.GetType());
+                    return;
+                }
+            }
             base.AddNode(node);
         }
 
             {
                 var nodes = new List<INode>();
                 //Get the rest of the nodes for all the other slots
-                NodeUtils.DepthFirstCollectNodesFromNode(nodes, outputNode, null, NodeUtils.IncludeSelf.Exclude);
+                NodeUtils.DepthFirstCollectNodesFromNode(nodes, outputNode, NodeUtils.IncludeSelf.Exclude);
                 return nodes.OfType<AbstractMaterialNode>();
             }
         }

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SubGraph/SubGraphNode.cs

                     onModified(this, ModificationScope.Graph);
             }
         }
+        
         /*
        // SAVED FOR LATER
         if (serializedVersion<kCurrentSerializedVersion)

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SurfaceModel/AbstractSurfaceMasterNode.cs

         public abstract string GetSurfaceOutputName();
         public abstract string GetLightFunction();
 
-        public override string GetShader(
-            GenerationMode mode,
-            out List<PropertyGenerator.TextureInfo> configuredTextures)
+        public override string GetSubShader(GenerationMode mode, PropertyGenerator shaderPropertiesVisitor)
-            var templateLocation = ShaderGenerator.GetTemplatePath("shader.template");
+            var templateLocation = ShaderGenerator.GetTemplatePath("subshader.template");
-            {
-                configuredTextures = new List<PropertyGenerator.TextureInfo>();
-            }
+
+            var activeNodeList = new List<INode>();
+            NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, this);
+            foreach (var node in activeNodeList.OfType<AbstractMaterialNode>())
+                node.GeneratePropertyBlock(shaderPropertiesVisitor, mode);
-
-            var shaderPropertiesVisitor = new PropertyGenerator();
+                shaderPropertyUsagesVisitor,
-                shaderPropertiesVisitor,
-                shaderPropertyUsagesVisitor,
-            
+
             var tagsVisitor = new ShaderGenerator();
             var blendingVisitor = new ShaderGenerator();
             var cullingVisitor = new ShaderGenerator();
             m_MaterialOptions.GetDepthTest(zTestVisitor);
             m_MaterialOptions.GetDepthWrite(zWriteVisitor);
 
-            var resultShader = templateText.Replace("${ShaderName}", GetType() + guid.ToString());
-            resultShader = resultShader.Replace("${ShaderPropertiesHeader}", shaderPropertiesVisitor.GetShaderString(2));
-            resultShader = resultShader.Replace("${ShaderPropertyUsages}", shaderPropertyUsagesVisitor.GetShaderString(2));
+            var resultShader = templateText.Replace("${ShaderPropertyUsages}", shaderPropertyUsagesVisitor.GetShaderString(2));
             resultShader = resultShader.Replace("${LightingFunctionName}", GetLightFunction());
             resultShader = resultShader.Replace("${SurfaceOutputStructureName}", GetSurfaceOutputName());
             resultShader = resultShader.Replace("${ShaderFunctions}", shaderFunctionVisitor.GetShaderString(2));
             resultShader = resultShader.Replace("${Culling}", cullingVisitor.GetShaderString(2));
             resultShader = resultShader.Replace("${ZTest}", zTestVisitor.GetShaderString(2));
             resultShader = resultShader.Replace("${ZWrite}", zWriteVisitor.GetShaderString(2));
+            resultShader = resultShader.Replace("${LOD}", ""+m_MaterialOptions.lod);
-            configuredTextures = shaderPropertiesVisitor.GetConfiguredTexutres();
+            return resultShader;
+        }
+
+        public override string GetFullShader(
+            GenerationMode mode,
+            out List<PropertyGenerator.TextureInfo> configuredTextures)
+        {
+            var templateLocation = ShaderGenerator.GetTemplatePath("shader.template");
-            return Regex.Replace(resultShader, @"\r\n|\n\r|\n|\r", Environment.NewLine);
+            if (!File.Exists(templateLocation))
+            {
+                configuredTextures = new List<PropertyGenerator.TextureInfo>();
+                return string.Empty;
+            }
+            var templateText = File.ReadAllText(templateLocation);
+            
+            var shaderPropertiesVisitor = new PropertyGenerator();
+            var resultShader = templateText.Replace("${ShaderName}", GetType() + guid.ToString());
+            resultShader = resultShader.Replace("${SubShader}", GetSubShader(mode, shaderPropertiesVisitor));
+            resultShader = resultShader.Replace("${ShaderPropertiesHeader}", shaderPropertiesVisitor.GetShaderString(2));
+            configuredTextures = shaderPropertiesVisitor.GetConfiguredTexutres();
+            return Regex.Replace(resultShader, @"\r\n|\n\r|\n|\r", Environment.NewLine);
+           ShaderGenerator propertyUsages,
-           PropertyGenerator shaderProperties,
-           ShaderGenerator propertyUsages,
            GenerationMode mode)
         {
             var activeNodeList = new List<INode>();
             {
                 if (node is IGeneratesFunction)
                     (node as IGeneratesFunction).GenerateNodeFunction(nodeFunction, mode);
-                
-                node.GeneratePropertyBlock(shaderProperties, mode);
+
                 node.GeneratePropertyUsages(propertyUsages, mode);
             }
 
                 shaderBody.AddShaderChunk("float4 " + ShaderGeneratorNames.VertexColor + " = IN.color;", true);
             }
 
-
             GenerateNodeCode(shaderBody, mode);
         }
 
             
             //Get the rest of the nodes for all the other slots
-            NodeUtils.DepthFirstCollectNodesFromNode(nodes, this, null, NodeUtils.IncludeSelf.Exclude);
+            NodeUtils.DepthFirstCollectNodesFromNode(nodes, this, NodeUtils.IncludeSelf.Exclude);
             for (var i = 0; i < nodes.Count; i++)
             {
                 var node = nodes[i];
                     if (fromNode == null)
                         continue;
 
+                    var remapper = fromNode as INodeGroupRemapper;
+                    if (remapper != null && !remapper.IsValidSlotConnection(outputRef.slotId))
+                        continue;
+
+
+                    if (slot.id == NormalSlotId)
+                        shaderBody.AddShaderChunk("o." + slot.shaderOutputName + " += 1e-6;", true);
                 }
             }
         }

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SurfaceModel/SurfaceMaterialOptions.cs

         private bool m_HalfAsView;
 
         [SerializeField]
+        private int m_LOD = 200;
+
+        [SerializeField]
         private bool m_Expanded;
 
         public void Init()
             noForwardAdd = false;
             approxView = false;
             halfAsView = false;
+            lod = 200;
         }
 
         public void GetTags(ShaderGenerator visitor)
         public bool noForwardAdd { get { return m_NoForwardAdd; } set { m_NoForwardAdd = value; } }
         public bool approxView { get { return m_ApproxView; } set { m_ApproxView = value; } }
         public bool halfAsView { get { return m_HalfAsView; } set { m_HalfAsView = value; } }
+        public int lod { get { return m_LOD; } set { m_LOD = value; } }
     }
 }

MaterialGraphProject/Assets/ShaderLOD.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class ShaderLOD : MonoBehaviour {
+
+	void OnGUI()
+    {
+        if (GUILayout.Button("200"))
+        {
+            Shader.globalMaximumLOD = 200;
+        }
+        if (GUILayout.Button("400"))
+        {
+            Shader.globalMaximumLOD = 400;
+        }
+    }
+}

MaterialGraphProject/Assets/ShaderLOD.cs.meta

+fileFormatVersion: 2
+guid: 4dae8f09bae183044ade8415d66232d2
+timeCreated: 1481294521
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/AssetCallbacks/CreateRemapGraph.cs

+using System.IO;
+using UnityEditor.ProjectWindowCallback;
+using UnityEngine.MaterialGraph;
+
+namespace UnityEditor.MaterialGraph
+{
+    public class CreateRemapGraph : EndNameEditAction
+    {
+        [MenuItem("Assets/Create/Remap Graph", false, 209)]
+        public static void CreateMaterialRemapGraph()
+        {
+            ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, CreateInstance<CreateRemapGraph>(),
+                "New Remap-Graph.remapGraph", null, null);
+        }
+
+        public override void Action(int instanceId, string pathName, string resourceFile)
+        {
+            var graph = CreateInstance<MaterialRemapAsset>();
+            graph.name = Path.GetFileName(pathName);
+            AssetDatabase.CreateAsset(graph, pathName);
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/AssetCallbacks/CreateRemapGraph.cs.meta

+fileFormatVersion: 2
+guid: 2870633e85d1cdd47b6b6d5e576187d1
+timeCreated: 1481188587
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/DrawData/RemapInputNodeDrawData.cs

+using System;
+using System.Collections.Generic;
+using RMGUI.GraphView;
+using UnityEditor.Graphing.Drawing;
+using UnityEngine;
+using UnityEngine.MaterialGraph;
+
+namespace UnityEditor.MaterialGraph.Drawing
+{
+    [Serializable]
+    class RemapInputControlDrawData : ControlDrawData
+    {
+        public override void OnGUIHandler()
+        {
+            base.OnGUIHandler();
+
+            var remapNode = node as MasterRemapInputNode;
+            if (remapNode == null)
+                return;
+
+            if (GUILayout.Button("Add Slot"))
+                remapNode.AddSlot();
+            if (GUILayout.Button("Remove Slot"))
+                remapNode.RemoveSlot();
+        }
+
+        public override float GetHeight()
+        {
+            return EditorGUIUtility.singleLineHeight * 2 + 3 * EditorGUIUtility.standardVerticalSpacing;
+        }
+    }
+
+    [Serializable]
+    public class RemapInputNodeDrawData : MaterialNodeDrawData
+    {
+        protected override IEnumerable<GraphElementData> GetControlData()
+        {
+            var instance = CreateInstance<RemapInputControlDrawData>();
+            instance.Initialize(node);
+            return new List<GraphElementData> { instance };
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/DrawData/RemapInputNodeDrawData.cs.meta

+fileFormatVersion: 2
+guid: 23e3fdefb76b26c428d70b010425e7af
+timeCreated: 1481189699
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/DrawData/RemapMasterNodeDrawData.cs

+using System;
+using System.Collections.Generic;
+using RMGUI.GraphView;
+using UnityEditor.Graphing.Drawing;
+using UnityEngine;
+using UnityEngine.MaterialGraph;
+
+namespace UnityEditor.MaterialGraph.Drawing
+{
+    [Serializable]
+    class RemapMasterControlDrawData : ControlDrawData
+    {
+        public override void OnGUIHandler()
+        {
+            base.OnGUIHandler();
+
+            var remapNode = node as RemapMasterNode;
+            if (remapNode == null)
+                return;
+
+            remapNode.remapAsset = (MaterialRemapAsset)EditorGUILayout.MiniThumbnailObjectField(
+                new GUIContent("Remap Asset"), 
+                remapNode.remapAsset, 
+                typeof(MaterialRemapAsset), null);
+        }
+
+        public override float GetHeight()
+        {
+            return EditorGUIUtility.singleLineHeight + 2 * EditorGUIUtility.standardVerticalSpacing;
+        }
+    }
+
+    [Serializable]
+    public class RemapMasterNodeDrawData : MaterialNodeDrawData
+    {
+        protected override IEnumerable<GraphElementData> GetControlData()
+        {
+            var instance = CreateInstance<RemapMasterControlDrawData>();
+            instance.Initialize(node);
+            return new List<GraphElementData> { instance };
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/DrawData/RemapMasterNodeDrawData.cs.meta

+fileFormatVersion: 2
+guid: 4bd257f009292e44aa3616abf24d3327
+timeCreated: 1481188375
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/DrawData/SurfaceMasterDrawData.cs

+using System;
+using System.Collections.Generic;
+using RMGUI.GraphView;
+using UnityEditor.Graphing.Drawing;
+using UnityEngine.MaterialGraph;
+
+namespace UnityEditor.MaterialGraph.Drawing
+{
+    [Serializable]
+    class SurfaceMasterContolDrawData : ControlDrawData
+    {
+        public override void OnGUIHandler()
+        {
+            base.OnGUIHandler();
+
+            var cNode = node as AbstractSurfaceMasterNode;
+            if (cNode == null)
+                return;
+
+            cNode.options.lod = EditorGUILayout.IntField("LOD", cNode.options.lod);
+        }
+
+        public override float GetHeight()
+        {
+            return EditorGUIUtility.singleLineHeight + 2 * EditorGUIUtility.standardVerticalSpacing;
+        }
+    }
+
+    [Serializable]
+    public class SurfaceMasterDrawData : MaterialNodeDrawData
+    {
+        protected override IEnumerable<GraphElementData> GetControlData()
+        {
+            var instance = CreateInstance<SurfaceMasterContolDrawData>();
+            instance.Initialize(node);
+            return new List<GraphElementData> { instance };
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/DrawData/SurfaceMasterDrawData.cs.meta

+fileFormatVersion: 2
+guid: 8a96d6b5dce22a748b50fa5a7629231e
+timeCreated: 1481294173
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Templates/subshader.template

+SubShader 
+{
+${Tags}
+${Blending}
+${Culling}
+${ZTest}
+${ZWrite}
+
+	LOD ${LOD}
+	
+	CGPROGRAM
+	#pragma target 3.0
+	#pragma surface surf ${LightingFunctionName} ${VertexShaderDecl}
+	#pragma glsl
+	#pragma debug
+
+${ShaderFunctions}
+${ShaderPropertyUsages}
+
+	struct Input 
+	{
+${ShaderInputs}
+	};
+
+	void vert (inout appdata_full v, out Input o)
+	{
+		UNITY_INITIALIZE_OUTPUT(Input,o);
+${VertexShaderBody}
+	}
+  
+	void surf (Input IN, inout ${SurfaceOutputStructureName} o) 
+	{
+${PixelShaderBody}
+	}
+	ENDCG
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Templates/subshader.template.meta

+fileFormatVersion: 2
+guid: 46fccd2bfdbe29d4d8743ad5e2454927
+timeCreated: 1481194716
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Remapper.meta

+fileFormatVersion: 2
+guid: 5f3c6a912dd29fb459196f8efdda853f
+folderAsset: yes
+timeCreated: 1481188026
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SurfaceModel/ProjectSpecificMasterNode.cs

+/*using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    public abstract class ProjectSpecificMasterNode : AbstractMasterNode
+    {
+        public override string GetSubShader(GenerationMode mode)
+        {
+           
+        }
+
+        public override string GetFullShader(
+            GenerationMode mode,
+            out List<PropertyGenerator.TextureInfo> configuredTextures)
+        {
+            var shaderTemplateLocation = ShaderGenerator.GetTemplatePath("shader.template");
+
+            if (!File.Exists(shaderTemplateLocation))
+            {
+                configuredTextures = new List<PropertyGenerator.TextureInfo>();
+                return string.Empty;
+            }
+
+            var templateText = File.ReadAllText(shaderTemplateLocation);
+
+            var shaderBodyVisitor = new ShaderGenerator();
+            var shaderFunctionVisitor = new ShaderGenerator();
+            var shaderPropertiesVisitor = new PropertyGenerator();
+            var shaderPropertyUsagesVisitor = new ShaderGenerator();
+            var shaderInputVisitor = new ShaderGenerator();
+            var vertexShaderBlock = new ShaderGenerator();
+
+            GenerateSurfaceShaderInternal(
+                shaderBodyVisitor,
+                shaderFunctionVisitor,
+                shaderInputVisitor,
+                vertexShaderBlock,
+                shaderPropertiesVisitor,
+                shaderPropertyUsagesVisitor,
+                mode);
+            
+            var tagsVisitor = new ShaderGenerator();
+            var blendingVisitor = new ShaderGenerator();
+            var cullingVisitor = new ShaderGenerator();
+            var zTestVisitor = new ShaderGenerator();
+            var zWriteVisitor = new ShaderGenerator();
+
+            m_MaterialOptions.GetTags(tagsVisitor);
+            m_MaterialOptions.GetBlend(blendingVisitor);
+            m_MaterialOptions.GetCull(cullingVisitor);
+            m_MaterialOptions.GetDepthTest(zTestVisitor);
+            m_MaterialOptions.GetDepthWrite(zWriteVisitor);
+
+            var resultShader = templateText.Replace("${ShaderName}", GetType() + guid.ToString());
+            resultShader = resultShader.Replace("${ShaderPropertiesHeader}", shaderPropertiesVisitor.GetShaderString(2));
+            resultShader = resultShader.Replace("${ShaderPropertyUsages}", shaderPropertyUsagesVisitor.GetShaderString(2));
+            resultShader = resultShader.Replace("${LightingFunctionName}", GetLightFunction());
+            resultShader = resultShader.Replace("${SurfaceOutputStructureName}", GetSurfaceOutputName());
+            resultShader = resultShader.Replace("${ShaderFunctions}", shaderFunctionVisitor.GetShaderString(2));
+            resultShader = resultShader.Replace("${ShaderInputs}", shaderInputVisitor.GetShaderString(3));
+            resultShader = resultShader.Replace("${PixelShaderBody}", shaderBodyVisitor.GetShaderString(3));
+            resultShader = resultShader.Replace("${Tags}", tagsVisitor.GetShaderString(2));
+            resultShader = resultShader.Replace("${Blending}", blendingVisitor.GetShaderString(2));
+            resultShader = resultShader.Replace("${Culling}", cullingVisitor.GetShaderString(2));
+            resultShader = resultShader.Replace("${ZTest}", zTestVisitor.GetShaderString(2));
+            resultShader = resultShader.Replace("${ZWrite}", zWriteVisitor.GetShaderString(2));
+
+            resultShader = resultShader.Replace("${VertexShaderDecl}", "vertex:vert");
+            resultShader = resultShader.Replace("${VertexShaderBody}", vertexShaderBlock.GetShaderString(3));
+
+            configuredTextures = shaderPropertiesVisitor.GetConfiguredTexutres();
+
+            return Regex.Replace(resultShader, @"\r\n|\n\r|\n|\r", Environment.NewLine);
+
+        }
+
+        private void GenerateSurfaceShaderInternal(
+           ShaderGenerator propertyUsages,
+           GenerationMode mode)
+        {
+            var activeNodeList = new List<INode>();
+            NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, this);
+
+            foreach (var node in activeNodeList.OfType<AbstractMaterialNode>())
+            {
+                node.GeneratePropertyUsages(propertyUsages, mode);
+            }
+
+        }
+    }
+}*/

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SurfaceModel/ProjectSpecificMasterNode.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Remapper/MasterRemapGraph.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Remapper/MasterRemapInputNode.cs.meta

+fileFormatVersion: 2
+guid: 39465109a68463a4b8a1a9c9dd20e46a
+timeCreated: 1481188026
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Remapper/MaterialRemapAsset.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Remapper/RemapMasterNode.cs.meta

+fileFormatVersion: 2
+guid: 8f94baf06fa91ad41bc0184e6d14cb0f
+timeCreated: 1481188026
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Remapper/MasterRemapGraph.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    public interface INodeGroupRemapper
+    {
+        void DepthFirstCollectNodesFromNodeSlotList(List<INode> nodeList, NodeUtils.IncludeSelf includeSelf);
+        bool IsValidSlotConnection(int id);
+    }
+
+    [Serializable]
+    public class MasterRemapGraph : AbstractMaterialGraph
+    {
+        [NonSerialized]
+        private MasterRemapInputNode m_InputNode;
+        
+        public MasterRemapInputNode inputNode
+        {
+            get
+            {
+                // find existing node
+                if (m_InputNode == null)
+                    m_InputNode = GetNodes<MasterRemapInputNode>().FirstOrDefault();
+
+                return m_InputNode;
+            }
+        }
+     
+        public override void OnAfterDeserialize()
+        {
+            base.OnAfterDeserialize();
+            m_InputNode = null;
+        }
+
+        public override void AddNode(INode node)
+        {
+            if (inputNode != null && node is MasterRemapInputNode)
+            {
+                Debug.LogWarning("Attempting to add second SubGraphInputNode to SubGraph. This is not allowed.");
+                return;
+            }
+
+            var materialNode = node as AbstractMaterialNode;
+            if (materialNode != null)
+            {
+                var amn = materialNode;
+                if (!amn.allowedInRemapGraph)
+                {
+                    Debug.LogWarningFormat("Attempting to add {0} to Remap Graph. This is not allowed.", amn.GetType());
+                    return;
+                }
+            }
+            base.AddNode(node);
+        }
+
+        struct DisposeMeh : IDisposable
+        {
+            private readonly MasterRemapInputNode m_Graph;
+
+            public DisposeMeh(MasterRemapInputNode graph, RemapMasterNode master)
+            {
+                m_Graph = graph;
+                graph.m_RemapTarget = master;
+            }
+
+            public void Dispose()
+            {
+                m_Graph.m_RemapTarget = null;
+            }
+        }
+
+        public List<string> GetSubShadersFor(RemapMasterNode rmn, GenerationMode mode, PropertyGenerator shaderPropertiesVisitor)
+        {
+            var subShaders = new List<string>();
+            try
+            {
+                using (new DisposeMeh(inputNode, rmn))
+                {
+                    foreach (var node in GetNodes<IMasterNode>())
+                        subShaders.Add(node.GetSubShader(mode, shaderPropertiesVisitor));
+                }
+            }
+            catch (Exception e)
+            {
+                Debug.LogException(e);
+            }
+            return subShaders;
+        }
+        
+        public void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
+        {
+            foreach (var node in GetNodes<AbstractMaterialNode>())
+                node.CollectPreviewMaterialProperties(properties);
+        }
+
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Remapper/MasterRemapInputNode.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Title("Remapper/Remap Input Node")]
+    public class MasterRemapInputNode : AbstractSubGraphIONode
+        , INodeGroupRemapper
+    {
+        [NonSerialized]
+        internal RemapMasterNode m_RemapTarget;
+
+        public MasterRemapInputNode()
+        {
+            name = "Inputs";
+        }
+
+        public override int AddSlot()
+        {
+            var nextSlotId = GetOutputSlots<ISlot>().Count() + 1;
+            AddSlot(new MaterialSlot(-nextSlotId, "Input " + nextSlotId, "Input" + nextSlotId, SlotType.Output, SlotValueType.Vector4, Vector4.zero));
+
+            if (onModified != null)
+            {
+                onModified(this, ModificationScope.Graph);
+            }
+
+            return -nextSlotId;
+        }
+
+        public override void RemoveSlot()
+        {
+            var lastSlotId = GetOutputSlots<ISlot>().Count();
+            if (lastSlotId == 0)
+                return;
+
+            RemoveSlot(-lastSlotId);
+
+            if (onModified != null)
+            {
+                onModified(this, ModificationScope.Graph);
+            }
+        }
+
+        public void DepthFirstCollectNodesFromNodeSlotList(List<INode> nodeList, NodeUtils.IncludeSelf includeSelf)
+        {
+            NodeUtils.DepthFirstCollectNodesFromNode(nodeList, m_RemapTarget, NodeUtils.IncludeSelf.Exclude);
+        }
+
+        public bool IsValidSlotConnection(int slotId)
+        {
+            if (m_RemapTarget == null)
+                return false;
+
+            var slot = m_RemapTarget.FindSlot<MaterialSlot>(slotId);
+            if (slot == null)
+                return false;
+
+            var edge = m_RemapTarget.owner.GetEdges(slot.slotReference).FirstOrDefault();
+            if (edge == null)
+                return false;
+
+            var outputRef = edge.outputSlot;
+            var fromNode = m_RemapTarget.owner.GetNodeFromGuid<AbstractMaterialNode>(outputRef.nodeGuid);
+            if (fromNode == null)
+                return false;
+
+            return true;
+        }
+
+        public override string GetVariableNameForSlot(int slotId)
+        {
+            if (m_RemapTarget == null)
+            {
+                var defaultValueSlot = FindSlot<MaterialSlot>(slotId);
+                if (defaultValueSlot == null)
+                    throw new ArgumentException(string.Format("Attempting to use MaterialSlot({0}) on node of type {1} where this slot can not be found", slotId, this), "slotId");
+
+                return defaultValueSlot.GetDefaultValue(GenerationMode.ForReals);
+            }
+
+            var slot = m_RemapTarget.FindSlot<MaterialSlot>(slotId);
+            if (slot == null)
+                throw new ArgumentException(string.Format("Attempting to use MaterialSlot({0}) on node of type {1} where this slot can not be found", slotId, this), "slotId");
+
+            if (slot.isOutputSlot)
+                throw new Exception(string.Format("Attempting to use OutputSlot({0}) on remap node)", slotId));
+
+            var edge = m_RemapTarget.owner.GetEdges(slot.slotReference).FirstOrDefault();
+            if (edge == null)
+                return slot.GetDefaultValue(GenerationMode.ForReals);
+
+            var outputRef = edge.outputSlot;
+            var fromNode = m_RemapTarget.owner.GetNodeFromGuid<AbstractMaterialNode>(outputRef.nodeGuid);
+            if (fromNode == null)
+                return slot.GetDefaultValue(GenerationMode.ForReals);
+
+            return fromNode.GetVariableNameForSlot(outputRef.slotId);
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Remapper/MaterialRemapAsset.cs

+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    public class MaterialRemapAsset : ScriptableObject, IMaterialGraphAsset
+    {
+        [SerializeField]
+        private MasterRemapGraph m_MasterRemapGraph = new MasterRemapGraph();
+
+        public IGraph graph
+        {
+            get { return m_MasterRemapGraph; }
+        }
+
+        public MasterRemapGraph masterRemapGraph
+        {
+            get { return m_MasterRemapGraph; }
+        }
+
+        public bool shouldRepaint
+        {
+            get { return graph.GetNodes<AbstractMaterialNode>().OfType<IRequiresTime>().Any(); }
+        }
+
+        public ScriptableObject GetScriptableObject()
+        {
+            return this;
+        }
+
+        public void OnEnable()
+        {
+            graph.OnEnable();
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Remapper/RemapMasterNode.cs

+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    [Title("Master/Remapper")]
+    public class RemapMasterNode : AbstractMasterNode
+        , IOnAssetEnabled
+    {
+        [SerializeField]
+        private string m_SerialziedRemapGraph = string.Empty;
+
+        [Serializable]
+        private class RemapGraphHelper
+        {
+            public MaterialRemapAsset subGraph;
+        }
+
+        public override bool allowedInRemapGraph
+        {
+            get { return false; }
+        }
+        
+        public override string GetFullShader(GenerationMode mode, out List<PropertyGenerator.TextureInfo> configuredTextures)
+        {
+            var shaderTemplateLocation = ShaderGenerator.GetTemplatePath("shader.template");
+
+            if (remapAsset == null || !File.Exists(shaderTemplateLocation))
+            {
+                configuredTextures = new List<PropertyGenerator.TextureInfo>();
+                return string.Empty;
+            }
+            
+            var shaderPropertiesVisitor = new PropertyGenerator();
+
+            // Step 1: Set this node as the remap target
+            // Pass in the shader properties visitor here as
+            // high level properties are shared
+            // this is only used for the header
+            var subShaders = remapAsset.masterRemapGraph.GetSubShadersFor(this, mode, shaderPropertiesVisitor);
+
+            var templateText = File.ReadAllText(shaderTemplateLocation);
+            var resultShader = templateText.Replace("${ShaderName}", GetType() + guid.ToString());
+            resultShader = resultShader.Replace("${ShaderPropertiesHeader}", shaderPropertiesVisitor.GetShaderString(2));
+            if (subShaders != null)
+                resultShader = resultShader.Replace("${SubShader}", subShaders.Aggregate(string.Empty, (i, j) => i + Environment.NewLine + j));
+            else
+                resultShader = resultShader.Replace("${SubShader}", string.Empty);
+
+            configuredTextures = shaderPropertiesVisitor.GetConfiguredTexutres();
+            return Regex.Replace(resultShader, @"\r\n|\n\r|\n|\r", Environment.NewLine);
+        }
+
+        public override string GetSubShader(GenerationMode mode, PropertyGenerator shaderPropertiesVisitor)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
+        {
+            base.CollectPreviewMaterialProperties(properties);
+            if (remapAsset == null)
+                return;
+
+            remapAsset.masterRemapGraph.CollectPreviewMaterialProperties(properties);
+        }
+
+#if UNITY_EDITOR
+        public MaterialRemapAsset remapAsset
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(m_SerialziedRemapGraph))
+                    return null;
+
+                var helper = new RemapGraphHelper();
+                EditorJsonUtility.FromJsonOverwrite(m_SerialziedRemapGraph, helper);
+                return helper.subGraph;
+            }
+            set
+            {
+                if (remapAsset == value)
+                    return;
+                    
+                var helper = new RemapGraphHelper();
+                helper.subGraph = value;
+                m_SerialziedRemapGraph = EditorJsonUtility.ToJson(helper, true);
+                OnEnable();
+
+                if (onModified != null)
+                    onModified(this, ModificationScope.Graph);
+            }
+        }
+#else
+        public MaterialSubGraphAsset subGraphAsset {get; set; }
+#endif
+        
+        public override PreviewMode previewMode
+        {
+            get
+            {
+                if (remapAsset == null)
+                    return PreviewMode.Preview2D;
+
+                return PreviewMode.Preview3D;
+            }
+        }
+
+        public RemapMasterNode()
+        {
+            name = "Remapper";
+        }
+
+        public void OnEnable()
+        {
+            var validNames = new List<int>();
+            if (remapAsset == null)
+            {
+                RemoveSlotsNameNotMatching(validNames);
+                return;
+            }
+
+            var inputNode = remapAsset.masterRemapGraph.inputNode;
+            foreach (var slot in inputNode.GetOutputSlots<MaterialSlot>())
+            {
+                AddSlot(new MaterialSlot(slot.id, slot.displayName, slot.shaderOutputName, SlotType.Input, slot.valueType, slot.defaultValue));
+                validNames.Add(slot.id);
+            }
+            RemoveSlotsNameNotMatching(validNames);
+        }
+    }
+}