temp

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/MaterialGraphPresenter.cs

             typeMapper[typeof(MasterRemapNode)] = typeof(MasterRemapNodePresenter);
 
             // typeMapper[typeof(MasterRemapInputNode)] = typeof(RemapInputNodePresenter);
-            typeMapper[typeof(AbstractSubGraphIONode)] = typeof(SubgraphIONodePresenter);
+            typeMapper[typeof(SubGraphOutputNode)] = typeof(SubgraphIONodePresenter);
 //            typeMapper[typeof(AbstractSurfaceMasterNode)] = typeof(SurfaceMasterNodePresenter);
             typeMapper[typeof(LevelsNode)] = typeof(LevelsNodePresenter);
             typeMapper[typeof(ConstantsNode)] = typeof(ConstantsNodePresenter);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/SubgraphIONodePresenter.cs

         {
             base.OnGUIHandler();
 
-            var ioNode = node as AbstractSubGraphIONode;
+            var ioNode = node as SubGraphOutputNode;
             if (ioNode == null)
                 return;
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Importers/ShaderGraphImporter.cs

             windowType = typeof(MaterialGraphEditWindow);
         else if (extension == ".ShaderSubGraph")
             windowType = typeof(SubGraphEditWindow);
+        else if (extension == ".ShaderRemapGraph")
+            windowType = typeof(MasterRemapGraph);
         else
             return;
         var windows = Resources.FindObjectsOfTypeAll(windowType);

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

 namespace UnityEngine.MaterialGraph
 {
     [Serializable]
-    public class MaterialGraph : AbstractMaterialGraph
+    public class MaterialGraph : AbstractMaterialGraph, IShaderGraph
     {
         public IMasterNode masterNode
         {

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

             get { return true; }
         }
 
+        public virtual bool allowedInMainGraph
+        {
+            get { return true; }
+        }
+
+        public virtual bool allowedInLayerGraph
+        {
+            get { return true; }
+        }
+
         public override bool hasError
         {
             get { return m_HasError; }

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

 
 namespace UnityEngine.MaterialGraph
 {
-    public class SubGraphOutputNode : AbstractSubGraphIONode
+    public class SubGraphOutputNode : AbstractMaterialNode
     {
         public SubGraphOutputNode()
         {
-        public override int AddSlot()
+        public virtual int AddSlot()
         {
             var index = GetInputSlots<ISlot>().Count() + 1;
             AddSlot(new MaterialSlot(index, "Output " + index, "Output" + index, SlotType.Input, SlotValueType.Vector4, Vector4.zero));
-        public override void RemoveSlot()
+        public virtual void RemoveSlot()
         {
             var index = GetInputSlots<ISlot>().Count();
             if (index == 0)

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

+using System.Collections.Generic;
+
+namespace UnityEngine.MaterialGraph
+{
+    interface IShaderGraph
+    {
+        string GetShader(string name, GenerationMode mode, out List<PropertyCollector.TextureInfo> configuredTextures);
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Graphs/IShaderGraph.cs.meta

+fileFormatVersion: 2
+guid: ad9b7f8f562a4ee59873c8c222874ce7
+timeCreated: 1507398800

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

+using System;
+using System.Collections.Generic;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    public class LayerWeightsOutputNode : AbstractMaterialNode, IOnAssetEnabled
+    {
+        public LayerWeightsOutputNode()
+        {
+            name = "LayerWeights";
+        }
+
+        public override bool allowedInRemapGraph { get; } = false;
+        public override bool allowedInSubGraph { get; } = false;
+
+        public void OnEnable()
+        {
+            var layeredGraph = owner as LayeredShaderGraph;
+            if (layeredGraph == null)
+                return;
+
+            var goodSlots =  new List<int>();
+            foreach (var layer in layeredGraph.layers)
+            {
+                AddSlot(new MaterialSlot(layer.layer, "" + layer.layer, "" + layer.layer, SlotType.Input, SlotValueType.Vector1, new Vector4(1, 0, 0, 0)));
+                goodSlots.Add(layer.layer);
+            }
+
+            RemoveSlotsNameNotMatching(goodSlots);
+        }
+    }
+}

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

+fileFormatVersion: 2
+guid: 789274d827ef4cb2a635638cb2a24718
+timeCreated: 1507401785

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

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    public class LayeredShaderGraph : AbstractMaterialGraph, IShaderGraph
+    {
+        [Serializable]
+        public class Layer
+        {
+            [SerializeField]
+            private int m_Layer;
+
+            [SerializeField]
+            private Shader m_Shader;
+
+            public Layer()
+            {
+                m_Layer = Guid.NewGuid().GetHashCode();
+            }
+
+            public int layer
+            {
+                get { return m_Layer; }
+            }
+
+            public Shader shader
+            {
+                get { return m_Shader; }
+                set { m_Shader = value; }
+            }
+        }
+
+        [NonSerialized]
+        private List<Layer> m_Layers = new List<Layer>();
+
+        [SerializeField]
+        List<SerializationHelper.JSONSerializedElement> m_SerializedLayers = new List<SerializationHelper.JSONSerializedElement>();
+
+        public IEnumerable<Layer> layers
+        {
+            get { return m_Layers; }
+        }
+
+        [NonSerialized]
+        private LayerWeightsOutputNode m_OutputNode;
+
+        public LayerWeightsOutputNode outputNode
+        {
+            get
+            {
+                // find existing node
+                if (m_OutputNode == null)
+                    m_OutputNode = GetNodes<LayerWeightsOutputNode>().FirstOrDefault();
+
+                return m_OutputNode;
+            }
+        }
+
+        public override void AddNode(INode node)
+        {
+            if (outputNode != null && node is LayerWeightsOutputNode)
+            {
+                Debug.LogWarning("Attempting to add second LayerWeightsOutputNode to LayeredShaderGraph. This is not allowed.");
+                return;
+            }
+
+            base.AddNode(node);
+        }
+
+        public void AddLayer()
+        {
+            m_Layers.Add(new Layer());
+        }
+
+        public void RemoveLayer()
+        {
+            m_Layers.Remove(m_Layers.Last());
+        }
+
+        public override void OnBeforeSerialize()
+        {
+            base.OnBeforeSerialize();
+            m_SerializedLayers = SerializationHelper.Serialize<Layer>(m_Layers);
+        }
+
+        public override void OnAfterDeserialize()
+        {
+            base.OnAfterDeserialize();
+            m_OutputNode = null;
+            m_Layers = SerializationHelper.Deserialize<Layer>(m_SerializedLayers, null);
+            m_SerializedLayers = null;
+        }
+
+        public string GetShader(string name, GenerationMode mode, out List<PropertyCollector.TextureInfo> configuredTextures)
+        {
+            PreviewMode pmode;
+            return GetShader(masterNode as AbstractMaterialNode, mode, name, out configuredTextures, out pmode);
+        }
+    }
+}

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

+fileFormatVersion: 2
+guid: 8ce99f0c764243ab9e2713566d4105af
+timeCreated: 1507398692

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

-fileFormatVersion: 2
-guid: fc663b99f48623e4b8c707625472d58f
-timeCreated: 1465559219
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

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

-namespace UnityEngine.MaterialGraph
-{
-    public abstract class AbstractSubGraphIONode : AbstractMaterialNode
-    {
-        public abstract int AddSlot();
-
-        public abstract void RemoveSlot();
-
-        /*public void FooterUI(GraphGUI host)
-        {
-            // TODO: make it pretty
-            GUIStyle style = this is SubGraphOutputNode ?
-                Styles.GetNodeStyle("shader in", Styles.Color.Aqua, false) :
-                Styles.GetNodeStyle("shader out", Styles.Color.Aqua, false);
-            var pos = GUILayoutUtility.GetRect(kTempContent, style);
-            int id = GUIUtility.GetControlID(FocusType.Passive);
-
-            Event evt = Event.current;
-            if (evt.type == EventType.Layout || evt.type == EventType.Used)
-                return;
-
-            switch (evt.GetTypeForControl(id))
-            {
-                case EventType.MouseUp:
-                    if (pos.Contains(evt.mousePosition) && evt.button == 0)
-                    {
-                        AddSlot();
-                        evt.Use();
-                    }
-                    break;
-                case EventType.Repaint:
-                    style.Draw(pos, kTempContent, id);
-                    break;
-            }
-        }*/
-    }
-}