Starting to work layer graph

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

         public override void Action(int instanceId, string pathName, string resourceFile)
         {
             var graph = new UnityEngine.MaterialGraph.MaterialGraph();
-//            graph.AddNode(new MetallicMasterNode());
+            graph.AddNode(new LightweightMetallicMasterNode());
             File.WriteAllText(pathName, EditorJsonUtility.ToJson(graph));
             AssetDatabase.Refresh();
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/AbstractMaterialGraphEditWindow.cs

         }
     }
 
+    public class LayeredGraphEditWindow : AbstractMaterialGraphEditWindow<LayeredShaderGraph>
+    {
+        public override AbstractMaterialGraph GetMaterialGraph()
+        {
+            return inMemoryAsset;
+        }
+    }
+
     public abstract class AbstractMaterialGraphEditWindow<TGraphType> : HelperMaterialGraphEditWindow where TGraphType : AbstractMaterialGraph
     {
         [SerializeField]
                 }
 
                 if (typeof(TGraphType) == typeof(UnityEngine.MaterialGraph.MaterialGraph))
+                    UpdateShaderGraphOnDisk(path);
+
+                if (typeof(TGraphType) == typeof(LayeredShaderGraph))
                     UpdateShaderGraphOnDisk(path);
 
                 if (typeof(TGraphType) == typeof(SubGraph))
 
         private void UpdateShaderGraphOnDisk(string path)
         {
-            var graph = inMemoryAsset as UnityEngine.MaterialGraph.MaterialGraph;
+            var graph = inMemoryAsset as IShaderGraph;
             if (graph == null)
                 return;
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Inspector/GraphInspectorView.cs

 
         VisualElement m_Title;
         VisualElement m_PropertyItems;
+        VisualElement m_LayerItems;
         VisualElement m_ContentContainer;
         AbstractNodeEditorView m_EditorView;
 
                 }
                 bottomContainer.Add(propertiesContainer);
 
+                //if (m_Presenter.graph is LayeredShaderGraph)
+                {
+                    var layersContainer = new VisualElement {name = "properties"};
+                    {
+                        var header = new VisualElement {name = "header"};
+                        {
+                            var title = new VisualElement {name = "title", text = "Layers"};
+                            header.Add(title);
+
+                            var addLayerButton = new Button(OnAddLayer) {text = "Add", name = "addButton"};
+                            header.Add(addLayerButton);
+                        }
+                        propertiesContainer.Add(header);
+
+                        m_LayerItems = new VisualContainer {name = "items"};
+                        propertiesContainer.Add(m_LayerItems);
+                    }
+                    bottomContainer.Add(layersContainer);
+                }
+
                 m_Preview = new Image { name = "preview", image = Texture2D.blackTexture};
                 bottomContainer.Add(m_Preview);
             }
             gm.AddItem(new GUIContent("Vector4"), false, () => m_Presenter.graph.AddShaderProperty(new Vector4ShaderProperty()));
             gm.AddItem(new GUIContent("Color"), false, () => m_Presenter.graph.AddShaderProperty(new ColorShaderProperty()));
             gm.AddItem(new GUIContent("Texture"), false, () => m_Presenter.graph.AddShaderProperty(new TextureShaderProperty()));
-                gm.ShowAsContext();
-            }
+            gm.ShowAsContext();
+        }
+
+        void OnAddLayer()
+        {
+            var layerGraph = m_Presenter.graph as LayeredShaderGraph;
+            if (layerGraph == null)
+                return;
+
+            layerGraph.AddLayer();
+        }
 
         public void OnChange(GraphInspectorPresenter.ChangeType changeType)
         {
                     m_ContentContainer.Clear();
                     if (presenter.selectedNodes.Count > 1)
                     {
-                        var element = new VisualElement { name = "selectionCount", text = string.Format("{0} nodes selected.", presenter.selectedNodes.Count) };
+                        var element = new VisualElement {name = "selectionCount", text = string.Format("{0} nodes selected.", presenter.selectedNodes.Count)};
-                        var view = (AbstractNodeEditorView)Activator.CreateInstance(m_TypeMapper.MapType(node.GetType()));
+                        var view = (AbstractNodeEditorView) Activator.CreateInstance(m_TypeMapper.MapType(node.GetType()));
                         view.node = node;
                         m_ContentContainer.Add(view);
                     }
                 {
                     m_Graph.onChange -= OnGraphChange;
                     m_PropertyItems.Clear();
+                    m_LayerItems.Clear();
                     m_Graph = null;
                 }
                 if (m_Presenter.graph != null)
                         m_PropertyItems.Add(new ShaderPropertyView(m_Graph, property));
+
+                    var layerGraph = m_Presenter.graph as LayeredShaderGraph;
+                    if (layerGraph != null)
+                        foreach (var layer in layerGraph.layers)
+                            m_LayerItems.Add(new ShaderLayerView(layerGraph, layer));
-        }
+            }
         }
 
         void OnGraphChange(GraphChange change)
                 var propertyView = m_PropertyItems.OfType<ShaderPropertyView>().FirstOrDefault(v => v.property.guid == propertyRemoved.guid);
                 if (propertyView != null)
                     m_PropertyItems.Remove(propertyView);
+            }
+
+            var layerGraph = m_Graph as LayeredShaderGraph;
+            if (layerGraph == null)
+                return;
+
+            var layerAdded = change as LayerAdded;
+            if (layerAdded != null)
+                    m_LayerItems.Add(new ShaderLayerView(layerGraph, layerAdded.layer));
+
+            var layerRemoved = change as LayerRemoved;
+            if (layerRemoved != null)
+            {
+                var view = m_LayerItems.OfType<ShaderLayerView>().FirstOrDefault(v => v.layer.layer == layerRemoved.id);
+                if (view != null)
+                    m_LayerItems.Remove(view);
             }
         }
 

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

 using System.IO;
 using System.Linq;
 using System.Text;
-using JetBrains.Annotations;
-using UnityEngine.Events;
-class ShaderGraphTextGenerator : ICustomShaderImporter
+class ShaderGraphImporter : ICustomShaderImporter
-    public string GetShaderText(string path)
+    private static string GetShaderText<T>(string path) where T : IShaderGraph
-            var graph = JsonUtility.FromJson<MaterialGraph>(textGraph);
+            var graph = JsonUtility.FromJson<T>(textGraph);
 
             var name = Path.GetFileNameWithoutExtension(path);
 
         return null;
     }
 
+    public string GetShaderText(string path)
+    {
+        if (path.EndsWith("LayeredShaderGraph", StringComparison.InvariantCultureIgnoreCase))
+            return GetShaderText<LayeredShaderGraph>(path);
+        if (path.EndsWith("shaderGraph", StringComparison.InvariantCultureIgnoreCase))
+            return GetShaderText<MaterialGraph>(path);
+
+        return null;
+    }
+
-        try
-        {
-            var textGraph = File.ReadAllText(path, Encoding.UTF8);
-            var graph = JsonUtility.FromJson<MaterialGraph>(textGraph);
-            return graph != null;
-        }
-        catch (Exception)
-        {
-            // ignored
-        }
-        return false;
+        return
+            path.EndsWith("LayeredShaderGraph", StringComparison.InvariantCultureIgnoreCase)
+            || path.EndsWith("shaderGraph", StringComparison.InvariantCultureIgnoreCase);
     }
 
     public void OpenAsset(string path)
 
-    private static void ShowGraphEditWindow(string path)
+    internal static void ShowGraphEditWindow(string path)
     {
         var asset = AssetDatabase.LoadAssetAtPath<Object>(path);
         var extension = Path.GetExtension(path);
+        else if (extension == ".LayeredShaderGraph")
+            windowType = typeof(LayeredGraphEditWindow);
         else if (extension == ".ShaderSubGraph")
             windowType = typeof(SubGraphEditWindow);
         else if (extension == ".ShaderRemapGraph")
+
         var windows = Resources.FindObjectsOfTypeAll(windowType);
         bool foundWindow = false;
         foreach (var w in windows.OfType<IMaterialGraphEditWindow>())

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

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

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

 
         public Guid guid { get; private set; }
     }
+
+    public class LayerAdded : GraphChange
+    {
+        public LayerAdded(LayeredShaderGraph.Layer layer)
+        {
+            this.layer = layer;
+        }
+
+        public LayeredShaderGraph.Layer layer { get; private set; }
+    }
+
+    public class LayerRemoved : GraphChange
+    {
+        public LayerRemoved(int id)
+        {
+            this.id = id;
+        }
+
+        public int id { get; private set; }
+    }
 }

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

             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)));
+                AddSlot(new MaterialSlot(layer.layer, "" + layer.layer, "" + layer.layer, SlotType.Input, SlotValueType.Vector1, new Vector4(0, 0, 0, 0)));
                 goodSlots.Add(layer.layer);
             }
 

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

 using System;
 using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using UnityEditor;
 using UnityEngine.Graphing;
 
 namespace UnityEngine.MaterialGraph
 
         public void AddLayer()
         {
-            m_Layers.Add(new Layer());
+            var layer = new Layer();
+            m_Layers.Add(layer);
+            NotifyChange(new LayerAdded(layer));
+
+            if (outputNode != null)
+                outputNode.onModified(outputNode, ModificationScope.Graph);
+        }
+
+        public bool SetLayer(int layerId, Shader newShader)
+        {
+            try
+            {
+                var path = AssetDatabase.GetAssetPath(newShader);
+
+                if (!path.EndsWith("shaderGraph", StringComparison.InvariantCultureIgnoreCase))
+                    return false;
+
+                var name = Path.GetFileNameWithoutExtension(path);
+                var textGraph = File.ReadAllText(path, Encoding.UTF8);
+                var graph = JsonUtility.FromJson<MaterialGraph>(textGraph);
+                if (graph == null)
+                    return false;
+
+                var layer = layers.FirstOrDefault(x => x.layer == layerId);
+                if (layer == null)
+                    return false;
+
+                layer.shader = newShader;
+
+                if (outputNode != null)
+                {
+                    outputNode.OnEnable();
+                    outputNode.onModified(outputNode, ModificationScope.Graph);
+                }
+
+                return true;
+            }
+            catch (Exception)
+            {
+                // ignored
+            }
+            return false;
-        public void RemoveLayer()
+        public void RemoveLayer(int id)
-            m_Layers.Remove(m_Layers.Last());
+            var num = m_Layers.RemoveAll(x => x.layer == id);
+
+            if (num > 0)
+            {
+                NotifyChange(new LayerRemoved(id));
+
+                if (outputNode != null)
+                    outputNode.onModified(outputNode, ModificationScope.Graph);
+            }
+
         }
 
         public override void OnBeforeSerialize()
 
         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);
+            configuredTextures = new List<PropertyCollector.TextureInfo>();
+            return string.Empty;
+            //PreviewMode pmode;
+            //return GetShader(masterNode as AbstractMaterialNode, mode, name, out configuredTextures, out pmode);
         }
     }
 }

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

+using System.IO;
+using UnityEditor.ProjectWindowCallback;
+using UnityEngine.MaterialGraph;
+
+namespace UnityEditor.MaterialGraph
+{
+    public class CreateLayeredShaderGraph : EndNameEditAction
+    {
+        [MenuItem("Assets/Create/Layered Shader Graph", false, 208)]
+        public static void CreateLayeredGraph()
+        {
+            ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, CreateInstance<CreateLayeredShaderGraph>(),
+                "New Layerd Shader Graph.LayeredShaderGraph", null, null);
+        }
+
+        public override void Action(int instanceId, string pathName, string resourceFile)
+        {
+            var graph = new LayeredShaderGraph();
+            graph.AddNode(new LayerWeightsOutputNode());
+            File.WriteAllText(pathName, EditorJsonUtility.ToJson(graph));
+            AssetDatabase.Refresh();
+        }
+    }
+}

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

+fileFormatVersion: 2
+guid: 0c11588a25854ed5bd03171503c84789
+timeCreated: 1507403047