Merge master

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

 
         public void RemoveShaderProperty(Guid guid)
         {
+            var propertyNodes = GetNodes<PropertyNode>().Where(x => x.propertyGuid == guid).ToArray();
+            foreach (var pNode in propertyNodes)
+                pNode.ReplaceWithConcreteNode();
+
             if (m_Properties.RemoveAll(x => x.guid == guid) > 0)
                 m_RemovedProperties.Add(guid);
         }

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

     public interface IShaderGraph
     {
         string GetShader(string name, GenerationMode mode, out List<PropertyCollector.TextureInfo> configuredTextures);
+        void LoadedFromDisk();
     }
 }

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

             PreviewMode pmode;
             return GetShader(masterNode as AbstractMaterialNode, mode, name, out configuredTextures, out pmode);
         }
-         
-        public override void OnAfterDeserialize()
+
+        public void LoadedFromDisk()
-            base.OnAfterDeserialize(); 
+            OnEnable();
+            ValidateGraph();
         }
     }
 }

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

                 foreach (var activeNode in nodes.OfType<AbstractMaterialNode>())
                 {
                     if (activeNode is IGeneratesBodyCode)
-                        (activeNode as IGeneratesBodyCode).GenerateNodeCode(surfaceOutputRemap,
-                            GenerationMode.ForReals);
+                        (activeNode as IGeneratesBodyCode).GenerateNodeCode(surfaceOutputRemap, GenerationMode.ForReals);
                 }
 
                 foreach (var input in GetInputSlots<MaterialSlot>())

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/ColorNode.cs

 namespace UnityEditor.ShaderGraph
 {
     [Title("Input/Basic/Color")]
-    public class ColorNode : AbstractMaterialNode, IGeneratesBodyCode
+    public class ColorNode : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
-        private const int kOutputSlotId = 0;
+        public const int OutputSlotId = 0;
         private const string kOutputSlotName = "Out";
 
         public ColorNode()
 
         public sealed override void UpdateNodeAfterDeserialization()
         {
-            AddSlot(new Vector4MaterialSlot(kOutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Vector4.zero));
-            RemoveSlotsNameNotMatching(new[] { kOutputSlotId });
+            AddSlot(new Vector4MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Vector4.zero));
+            RemoveSlotsNameNotMatching(new[] { OutputSlotId });
         }
 
         [ColorControl("")]
                 m_Color = color
             });
         }
+        
+        public IShaderProperty AsShaderProperty()
+        {
+            var prop = new ColorShaderProperty();
+            prop.value = color;
+            return prop;
+        }
+
+        public int outputSlotId { get { return OutputSlotId; } }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/Vector1Node.cs

 namespace UnityEditor.ShaderGraph
 {
     [Title("Input/Basic/Vector 1")]
-    public class Vector1Node : AbstractMaterialNode, IGeneratesBodyCode
+    public class Vector1Node : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
     {
         [SerializeField]
         private float m_Value;
         /*[SerializeField]
         private FloatPropertyChunk.FloatType m_floatType;*/
 
-        // [SerializeField]
+       // [SerializeField]
         //private Vector3 m_rangeValues = new Vector3(0f, 1f, 2f);
 
         public Vector1Node()
                 m_Float = m_Value
             });
         }
+
+
+        public IShaderProperty AsShaderProperty()
+        {
+            var prop = new FloatShaderProperty();
+            prop.value = value;
+            return prop;
+        }
+
+        public int outputSlotId { get { return OutputSlotId; } }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/Vector2Node.cs

 namespace UnityEditor.ShaderGraph
 {
     [Title("Input/Basic/Vector 2")]
-    public class Vector2Node : AbstractMaterialNode, IGeneratesBodyCode
+    public class Vector2Node : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
     {
         [SerializeField]
         private Vector2 m_Value;
                 m_Vector4 = m_Value
             });
         }
+
+        public IShaderProperty AsShaderProperty()
+        {
+            var prop = new Vector2ShaderProperty();
+            prop.value = value;
+            return prop;
+        }
+
+        public int outputSlotId { get { return OutputSlotId; } }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/Vector3Node.cs

-using System;
 using System.Collections.Generic;
 using UnityEditor.ShaderGraph.Drawing.Controls;
 using UnityEngine;
 {
     [Title("Input/Basic/Vector 3")]
-    public class Vector3Node : AbstractMaterialNode, IGeneratesBodyCode
-    {
+    public class Vector3Node : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
+    { 
         [SerializeField]
         private Vector3 m_Value;
 
                 m_Vector4 = m_Value
             });
         }
+
+        public IShaderProperty AsShaderProperty()
+        {
+            var prop = new Vector3ShaderProperty();
+            prop.value = value;
+            return prop;
+        }
+
+        public int outputSlotId { get { return OutputSlotId; } }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/Vector4Node.cs

 namespace UnityEditor.ShaderGraph
 {
     [Title("Input/Basic/Vector 4")]
-    public class Vector4Node : AbstractMaterialNode, IGeneratesBodyCode
+    public class Vector4Node : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
     {
         [SerializeField]
         private Vector4 m_Value;
                 m_Vector4 = m_Value
             });
         }
+        
+        public IShaderProperty AsShaderProperty()
+        {
+            var prop = new Vector4ShaderProperty();
+            prop.value = value;
+            return prop;
+        }
+
+        public int outputSlotId { get { return OutputSlotId; } }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Vector/TransformNode.cs

 using UnityEditor.Graphing;
-using System.Collections.Generic;
 using UnityEditor.ShaderGraph.Drawing.Controls;
 using UnityEngine;
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/PropertyNode.cs

         {
             UpdateNode();
         }
+
+        public void ReplaceWithConcreteNode()
+        {
+            var matGraph = owner as MaterialGraph;
+            if (matGraph == null)
+                return;
+
+            var property = matGraph.properties.FirstOrDefault(x => x.guid == propertyGuid);
+            if (property != null)
+            {
+                AbstractMaterialNode node = null;
+                int slotId = -1;
+                if (property is FloatShaderProperty)
+                {
+                    var createdNode = new Vector1Node();
+                    createdNode.value = ((FloatShaderProperty) property).value;
+                    slotId = Vector1Node.OutputSlotId;
+                    node = createdNode;
+                }
+                else if (property is Vector2ShaderProperty)
+                {
+                    var createdNode = new Vector2Node();
+                    createdNode.value = ((Vector2ShaderProperty) property).value;
+                    slotId = Vector2Node.OutputSlotId;
+                    node = createdNode;
+                }
+                else if (property is Vector3ShaderProperty)
+                {
+                    var createdNode = new Vector3Node();
+                    createdNode.value = ((Vector3ShaderProperty) property).value;
+                    slotId = Vector3Node.OutputSlotId;
+                    node = createdNode;
+                }
+                else if (property is Vector4ShaderProperty)
+                {
+                    var createdNode = new Vector4Node();
+                    createdNode.value = ((Vector4ShaderProperty) property).value;
+                    slotId = Vector4Node.OutputSlotId;
+                    node = createdNode;
+                }
+                else if (property is ColorShaderProperty)
+                {
+                    var createdNode = new ColorNode();
+                    createdNode.color = ((ColorShaderProperty) property).value;
+                    slotId = ColorNode.OutputSlotId;
+                    node = createdNode;
+                }
+
+                if (node == null)
+                    return;
+
+                var slot = FindOutputSlot<MaterialSlot>(OutputSlotId);
+                node.drawState = drawState;
+                owner.AddNode(node);
+
+                foreach (var edge in owner.GetEdges(slot.slotReference).ToArray())
+                    owner.Connect(node.GetSlotReference(slotId), edge.inputSlot);
+
+                owner.RemoveNode(this);
+            }
+        }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/SubGraph/LayeredShaderGraph.cs

 using System.IO;
 using System.Linq;
 using System.Text;
-using UnityEditor;
 using UnityEngine;
 using UnityEditor.Graphing;
 
             return finalShader.GetShaderString(0);
         }
 
+        public void LoadedFromDisk()
+        {
+            OnEnable();
+            ValidateGraph();
+        }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Controls/DefaultControl.cs

 using System.Reflection;
 using UnityEngine;
 using UnityEngine.Experimental.UIElements;
-using UnityEditor.ShaderGraph;
 using Object = UnityEngine.Object;
 
 namespace UnityEditor.ShaderGraph.Drawing.Controls

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Controls/EnumControl.cs

 using System.Reflection;
 using UnityEngine;
 using UnityEngine.Experimental.UIElements;
-using UnityEditor.ShaderGraph;
 
 namespace UnityEditor.ShaderGraph.Drawing.Controls
 {

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

 using UnityEngine.Experimental.UIElements;
 using UnityEditor.Graphing;
-using UnityEditor.ShaderGraph;
 using UnityEngine;
 
 namespace UnityEditor.ShaderGraph.Drawing.Inspector

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Manipulators/NodeCreator.cs

 using System;
+using System.Linq;
 using System.Reflection;
 using UnityEditor.Experimental.UIElements.GraphView;
 using UnityEngine;
                         m_Menu.AddItem(new GUIContent(attrs[0].m_Title), false, OnAddNode, type);
                 }
             }
+
+            m_Menu.AddSeparator("");
+            m_Menu.AddItem(new GUIContent("Convert to Property"), false, OnConvertToProperty);
+            m_Menu.AddItem(new GUIContent("Convert to Inline node"), false, OnConvertToInlineNode);
+        }
+
+        private void OnConvertToInlineNode()
+        {
+            if (m_GraphView == null)
+                return;
+
+            var slected = m_GraphView.selection.OfType<MaterialNodeView>()
+                .Select(x => x.node)
+                .OfType<PropertyNode>();
+
+            foreach (var propNode in slected)
+                propNode.ReplaceWithConcreteNode();
+        }
+
+        private void OnConvertToProperty()
+        {
+            if (m_GraphView == null)
+                return;
+
+            var graph = m_Graph as AbstractMaterialGraph;
+            if (graph == null)
+                return;
+
+            var slected = m_GraphView.selection.OfType<MaterialNodeView>().Select(x => x.node);
+
+            foreach (var node in slected.ToArray())
+            {
+                if (!(node is IPropertyFromNode))
+                    continue;
+
+                var converter = node as IPropertyFromNode;
+                var prop = converter.AsShaderProperty();
+                graph.AddShaderProperty(prop);
+
+                var propNode = new PropertyNode();
+                propNode.drawState = node.drawState;
+                graph.AddNode(propNode);
+                propNode.propertyGuid = prop.guid;
+
+                var oldSlot = node.FindSlot<MaterialSlot>(converter.outputSlotId);
+                var newSlot = propNode.FindSlot<MaterialSlot>(PropertyNode.OutputSlotId);
+
+                var edges = graph.GetEdges(oldSlot.slotReference).ToArray();
+                foreach (var edge in edges)
+                    graph.Connect(newSlot.slotReference, edge.inputSlot);
+
+                graph.RemoveNode(node);
+            }
         }
 
         void OnAddNode(object userData)
             m_Graph.AddNode(node);
         }
 
+        private GraphView m_GraphView;
-            var graphView = target as GraphView;
-            if (graphView == null)
+            m_GraphView = target as GraphView;
+            if (m_GraphView == null)
-            m_ContentViewContainer = graphView.contentViewContainer;
+
+            m_ContentViewContainer = m_GraphView.contentViewContainer;
             target.RegisterCallback<MouseUpEvent>(OnMouseUp);
         }
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Views/GraphEditorView.cs

         ToolbarView m_ToolbarView;
         ToolbarButtonView m_TimeButton;
         ToolbarButtonView m_CopyToClipboardButton;
-
+        
         PreviewManager m_PreviewManager;
 
         public Action onUpdateAssetClick { get; set; }

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

 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using System.Text;
 using UnityEditor;
 using UnityEditor.ShaderGraph.Drawing;
         {
             var textGraph = File.ReadAllText(path, Encoding.UTF8);
             var graph = JsonUtility.FromJson<T>(textGraph);
+            graph.LoadedFromDisk();
 
             var name = Path.GetFileNameWithoutExtension(path);
 
 
     public bool IsValidForPath(string path)
     {
-
         return
             path.EndsWith("LayeredShaderGraph", StringComparison.InvariantCultureIgnoreCase)
             || path.EndsWith("shaderGraph", StringComparison.InvariantCultureIgnoreCase);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/IPropertyFromNode.cs

+namespace UnityEditor.ShaderGraph
+{
+    interface IPropertyFromNode
+    {
+        IShaderProperty AsShaderProperty();
+        int outputSlotId { get; }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/IPropertyFromNode.cs.meta

+fileFormatVersion: 2
+guid: 01ab4daa0c099e24e90bbb8623a4198b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/DefaultShaderIncludes.cs

+namespace UnityEditor
+{
+    internal static class DefaultShaderIncludes
+    {
+        [ShaderIncludePath]
+        public static string[] GetPaths()
+        {
+            return new[]
+            {
+                "Assets/ScriptableRenderPipeline/",
+                "Assets/SRP/ScriptableRenderPipeline/LightweightPipeline/Shaders"
+            };
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/DefaultShaderIncludes.cs.meta

+fileFormatVersion: 2
+guid: c5c6fed447622d14cabac1b6abcdd8a9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: