[mat graph]Start work on remapper

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(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);
 
         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);
     }
 }

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 override bool allowedInRemapGraph
+        {
+            get { return false; }
+        }
+
         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;
             }
+
+            if (node is AbstractMaterialNode)
+            {
+                var amn = (AbstractMaterialNode)node;
+                if (!amn.allowedInSubGraph)
+                    Debug.LogWarningFormat("Attempting to add {0} to Sub Graph. This is not allowed.", amn.GetType());
+            }
             base.AddNode(node);
         }
 

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

                     onModified(this, ModificationScope.Graph);
             }
         }
+
+        public override bool allowedInRemapGraph
+        {
+            get { return false; }
+        }
+
         /*
        // 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)
-            var templateLocation = ShaderGenerator.GetTemplatePath("shader.template");
+            var templateLocation = ShaderGenerator.GetTemplatePath("subshader.template");
-            {
-                configuredTextures = new List<PropertyGenerator.TextureInfo>();
-            }
-
+            
-            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("${VertexShaderDecl}", "vertex:vert");
             resultShader = resultShader.Replace("${VertexShaderBody}", vertexShaderBlock.GetShaderString(3));
 
+            return resultShader;
+        }
+
+        public override string GetFullShader(
+            GenerationMode mode,
+            out List<PropertyGenerator.TextureInfo> configuredTextures)
+        {
+            var templateLocation = ShaderGenerator.GetTemplatePath("shader.template");
+
+            if (!File.Exists(templateLocation))
+            {
+                configuredTextures = new List<PropertyGenerator.TextureInfo>();
+                return string.Empty;
+            }
+
+            var templateText = File.ReadAllText(templateLocation);
+
+            var activeNodeList = new List<INode>();
+            NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, this);
+
+            var shaderPropertiesVisitor = new PropertyGenerator();
+            foreach (var node in activeNodeList.OfType<AbstractMaterialNode>())
+                node.GeneratePropertyBlock(shaderPropertiesVisitor, mode);
+
+            var resultShader = templateText.Replace("${ShaderName}", GetType() + guid.ToString());
+            resultShader = resultShader.Replace("${ShaderPropertiesHeader}", shaderPropertiesVisitor.GetShaderString(2));
+            resultShader = resultShader.Replace("${SubShader}", GetSubShader(mode));
-
-
+           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);
         }

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/Templates/subshader.template

+SubShader 
+{
+${Tags}
+${Blending}
+${Culling}
+${ZTest}
+${ZWrite}
+
+	LOD 200
+	
+	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/Remapper/MasterRemapGraph.cs

+using System;
+using System.Linq;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    [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;
+            }
+
+            if (node is AbstractMaterialNode)
+            {
+                var amn = (AbstractMaterialNode) node;
+                if (!amn.allowedInRemapGraph)
+                    Debug.LogWarningFormat("Attempting to add {0} to Remap Graph. This is not allowed.", amn.GetType());
+            }
+
+            if (node is IGenerateProperties)
+            {
+                Debug.LogWarning("Attempting to add second SubGraphInputNode to SubGraph. This is not allowed.");
+                return;
+            }
+            base.AddNode(node);
+        }
+    }
+}

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

+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Title("Remapper/Remap Input Node")]
+    public class MasterRemapInputNode : AbstractSubGraphIONode
+    {
+        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 override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
+        {
+            if (generationMode == GenerationMode.ForReals)
+                return;
+
+            foreach (var slot in GetOutputSlots<MaterialSlot>())
+            {
+                var outDimension = ConvertConcreteSlotValueTypeToString(slot.concreteValueType);
+                visitor.AddShaderChunk("float" + outDimension + " " + GetVariableNameForSlot(slot.id) + ";", true);
+            }
+        }
+
+        public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
+        {
+            base.CollectPreviewMaterialProperties(properties);
+            foreach (var slot in GetOutputSlots<MaterialSlot>())
+            {
+                properties.Add(
+                    new PreviewProperty
+                {
+                    m_Name = GetVariableNameForSlot(slot.id),
+                    m_PropType = PropertyType.Vector4,
+                    m_Vector4 = slot.defaultValue
+                }
+                    );
+            }
+        }
+    }
+}

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

+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/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

+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    [Title("Master/Remapper")]
+    public class RemapMasterNode : AbstractMasterNode
+    {
+        [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)
+        {
+            throw new NotImplementedException();
+            var shaderTemplateLocation = ShaderGenerator.GetTemplatePath("shader.template");
+
+            if (remapAsset == null || !File.Exists(shaderTemplateLocation))
+            {
+                configuredTextures = new List<PropertyGenerator.TextureInfo>();
+                return string.Empty;
+            }
+            
+            // Step 1: Generate properties from this node
+            // remap graphs are not allowed to have subgraphs
+            // or property nodes, so this is okay :)
+            var shaderPropertiesVisitor = new ShaderGenerator();
+            var activeNodeList = new List<INode>();
+            NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, this);
+
+            foreach (var node in activeNodeList.OfType<AbstractMaterialNode>())
+                node.GeneratePropertyUsages(shaderPropertiesVisitor, mode);
+
+            var subShaders = new List<string>();
+            foreach (var node in activeNodeList.OfType<IMasterNode>())
+                subShaders.Add(node.GetSubShader(mode));
+
+
+        }
+
+        public void GenerateNodeCode(ShaderGenerator shaderBody, GenerationMode generationMode)
+        {
+            var nodes = ListPool<INode>.Get();
+
+            //Get the rest of the nodes for all the slots
+            NodeUtils.DepthFirstCollectNodesFromNode(nodes, this, null, NodeUtils.IncludeSelf.Exclude);
+            for (var i = 0; i < nodes.Count; i++)
+            {
+                var node = nodes[i];
+                if (node is IGeneratesBodyCode)
+                    (node as IGeneratesBodyCode).GenerateNodeCode(shaderBody, generationMode);
+            }
+            ListPool<INode>.Release(nodes);
+
+            foreach (var slot in GetInputSlots<MaterialSlot>())
+            {
+                var edge = owner.GetEdges(slot.slotReference).FirstOrDefault();
+
+                if (edge != null)
+                {
+                    var outputRef = edge.outputSlot;
+                    var fromNode = owner.GetNodeFromGuid<AbstractMaterialNode>(outputRef.nodeGuid);
+                    if (fromNode == null)
+                        continue;
+
+                    shaderBody.AddShaderChunk("float4 reamapper_" + slot.shaderOutputName + " = " + fromNode.GetVariableNameForSlot(outputRef.slotId) + ";", true);
+                }
+                else
+                {
+                    shaderBody.AddShaderChunk("float4 reamapper_" + slot.shaderOutputName + " = 0;", true);
+                }
+            }
+        }
+
+        public override string GetSubShader(GenerationMode mode)
+        {
+            throw new NotImplementedException();
+        }
+
+#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
+
+        private MasterRemapGraph masterRemapGraph
+        {
+            get
+            {
+                if (remapAsset == null)
+                    return null;
+
+                return remapAsset.masterRemapGraph;
+            }
+        }
+        
+        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);
+        }
+    }
+}

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: