Merge branch 'master' into node-bugfixes

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

 {
     public class CreateShaderSubGraph : EndNameEditAction
     {
-        [MenuItem("Assets/Create/Shader Sub Graph", false, 208)]
+        [MenuItem("Assets/Create/Shader/Sub Graph", false, 208)]
         public static void CreateMaterialSubGraph()
         {
             ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, CreateInstance<CreateShaderSubGraph>(),

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

         {
             if (!node.canDeleteNode)
                 return;
+            RemoveNodeNoValidate(node);
             ValidateGraph();
         }
 
 
         [NonSerialized]
         public Quaternion rotation = Quaternion.identity;
+
+        [NonSerialized]
+        public float scale = 1f;
     }
 }

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

 using System;
 using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Slots;
+using UnityEngine.Experimental.UIElements;
 
 namespace UnityEditor.ShaderGraph
 {
+        [SerializeField]
+        ScreenSpaceType m_ScreenSpaceType;
+
+        public ScreenSpaceType screenSpaceType
+        {
+            get { return m_ScreenSpaceType; }
+            set { m_ScreenSpaceType = value; }
+        }
+
-        public ScreenPositionMaterialSlot(int slotId, string displayName, string shaderOutputName,
+        public ScreenPositionMaterialSlot(int slotId, string displayName, string shaderOutputName, ScreenSpaceType screenSpaceType,
-        {}
+        {
+            this.screenSpaceType = screenSpaceType;
+        }
+
+        public override VisualElement InstantiateControl()
+        {
+            return new ScreenPositionSlotControlView(this);
+        }
-            return string.Format("IN.{0}", ShaderGeneratorNames.ScreenPosition);
+            return m_ScreenSpaceType.ToValueAsVariable();
+        }
+
+        public override void CopyValuesFrom(MaterialSlot foundSlot)
+        {
+            var slot = foundSlot as ScreenPositionMaterialSlot;
+            if (slot != null)
+                screenSpaceType = slot.screenSpaceType;
         }
     }
 }

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

     public class UVMaterialSlot : Vector2MaterialSlot, IMayRequireMeshUV
     {
         [SerializeField]
-        private UVChannel m_Channel = UVChannel.UV0;
+        UVChannel m_Channel = UVChannel.UV0;
 
         public UVChannel channel
         {

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

             set { m_Name = value; }
         }
 
+        public virtual string documentationURL
+        {
+            get { return null; }
+        }
+
         public virtual bool canDeleteNode
         {
             get { return true; }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Artistic/Adjustment/ReplaceColorNode.cs

             [Slot(1, Binding.None)] ColorRGB From,
             [Slot(2, Binding.None)] ColorRGB To,
             [Slot(3, Binding.None)] Vector1 Range,
+            [Slot(5, Binding.None)] Vector1 Fuzziness,
-            Out = Vector2.zero;
+            Out = Vector3.zero;
-    {precision}3 col = In;
-    if(Distance <= Range)
-        col = To;
-    Out = col;
+    Out = lerp(To, In, saturate((Distance - Range) / max(Fuzziness, 1e-5f)));
 }";
         }
     }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Artistic/Blend/BlendNode.cs

         static string Unity_Blend_Burn(
             [Slot(0, Binding.None)] DynamicDimensionVector Base,
             [Slot(1, Binding.None)] DynamicDimensionVector Blend,
+            [Slot(3, Binding.None, 1, 1, 1, 1)] Vector1 Opacity,
             [Slot(2, Binding.None)] out DynamicDimensionVector Out)
         {
             return
+    Out = lerp(Base, Out, Opacity);
 }";
         }
 
+            [Slot(3, Binding.None, 1, 1, 1, 1)] Vector1 Opacity,
             [Slot(2, Binding.None)] out DynamicDimensionVector Out)
         {
             return
+    Out = lerp(Base, Out, Opacity);
 }";
         }
 
+            [Slot(3, Binding.None, 1, 1, 1, 1)] Vector1 Opacity,
             [Slot(2, Binding.None)] out DynamicDimensionVector Out)
         {
             return
+    Out = lerp(Base, Out, Opacity);
 }";
         }
 
+            [Slot(3, Binding.None, 1, 1, 1, 1)] Vector1 Opacity,
             [Slot(2, Binding.None)] out DynamicDimensionVector Out)
         {
             return
+    Out = lerp(Base, Out, Opacity);
 }";
         }
 
+            [Slot(3, Binding.None, 1, 1, 1, 1)] Vector1 Opacity,
             [Slot(2, Binding.None)] out DynamicDimensionVector Out)
         {
             return
+    Out = lerp(Base, Out, Opacity);
 }";
         }
 
+            [Slot(3, Binding.None, 1, 1, 1, 1)] Vector1 Opacity,
             [Slot(2, Binding.None)] out DynamicDimensionVector Out)
         {
             return
+    Out = lerp(Base, Out, Opacity);
 }";
         }
 
+            [Slot(3, Binding.None, 1, 1, 1, 1)] Vector1 Opacity,
             [Slot(2, Binding.None)] out DynamicDimensionVector Out)
         {
             return
     {precision}{slot2dimension} result2 = 2.0 * Base * Blend;
     {precision}{slot2dimension} zeroOrOne = step(Blend, 0.5);
     Out = result2 * zeroOrOne + (1 - zeroOrOne) * result1;
+    Out = lerp(Base, Out, Opacity);
 }";
         }
 
+            [Slot(3, Binding.None, 1, 1, 1, 1)] Vector1 Opacity,
             [Slot(2, Binding.None)] out DynamicDimensionVector Out)
         {
             return
+    Out = lerp(Base, Out, Opacity);
 }";
         }
 
+            [Slot(3, Binding.None, 1, 1, 1, 1)] Vector1 Opacity,
             [Slot(2, Binding.None)] out DynamicDimensionVector Out)
         {
             return
+    Out = lerp(Base, Out, Opacity);
 }";
         }
 
+            [Slot(3, Binding.None, 1, 1, 1, 1)] Vector1 Opacity,
             [Slot(2, Binding.None)] out DynamicDimensionVector Out)
         {
             return
+    Out = lerp(Base, Out, Opacity);
 }";
         }
 
+            [Slot(3, Binding.None, 1, 1, 1, 1)] Vector1 Opacity,
             [Slot(2, Binding.None)] out DynamicDimensionVector Out)
         {
             return
+    Out = lerp(Base, Out, Opacity);
 }";
         }
 
+            [Slot(3, Binding.None, 1, 1, 1, 1)] Vector1 Opacity,
             [Slot(2, Binding.None)] out DynamicDimensionVector Out)
         {
             return
+    Out = lerp(Base, Out, Opacity);
 }";
         }
 
+            [Slot(3, Binding.None, 1, 1, 1, 1)] Vector1 Opacity,
             [Slot(2, Binding.None)] out DynamicDimensionVector Out)
         {
             return
+    Out = lerp(Base, Out, Opacity);
 }";
         }
 
+            [Slot(3, Binding.None, 1, 1, 1, 1)] Vector1 Opacity,
             [Slot(2, Binding.None)] out DynamicDimensionVector Out)
         {
             return
+    Out = lerp(Base, Out, Opacity);
 }";
         }
 
+            [Slot(3, Binding.None, 1, 1, 1, 1)] Vector1 Opacity,
             [Slot(2, Binding.None)] out DynamicDimensionVector Out)
         {
             return
+    Out = lerp(Base, Out, Opacity);
 }";
         }
 
+            [Slot(3, Binding.None, 1, 1, 1, 1)] Vector1 Opacity,
             [Slot(2, Binding.None)] out DynamicDimensionVector Out)
         {
             return
+    Out = lerp(Base, Out, Opacity);
 }";
         }
 
+            [Slot(3, Binding.None, 1, 1, 1, 1)] Vector1 Opacity,
             [Slot(2, Binding.None)] out DynamicDimensionVector Out)
         {
             return
     {precision}{slot2dimension} result2 = 2.0 * Base * Blend;
     {precision}{slot2dimension} zeroOrOne = step(Base, 0.5);
     Out = result2 * zeroOrOne + (1 - zeroOrOne) * result1;
+    Out = lerp(Base, Out, Opacity);
 }
 ";
         }
             [Slot(1, Binding.None)] DynamicDimensionVector Blend,
+            [Slot(3, Binding.None, 1, 1, 1, 1)] Vector1 Opacity,
             [Slot(2, Binding.None)] out DynamicDimensionVector Out)
         {
             return
     {precision}{slot2dimension} result1 = check * max(2.0 * (Base - 0.5), Blend);
     Out = result1 + (1.0 - check) * min(2.0 * Base, Blend);
+    Out = lerp(Base, Out, Opacity);
 }
 ";
         }
             [Slot(1, Binding.None)] DynamicDimensionVector Blend,
+            [Slot(3, Binding.None, 1, 1, 1, 1)] Vector1 Opacity,
             [Slot(2, Binding.None)] out DynamicDimensionVector Out)
         {
             return
     {precision}{slot2dimension} result2 = sqrt(Base) * (2.0 * Blend - 1.0) + 2.0 * Base * (1.0 - Blend);
     {precision}{slot2dimension} zeroOrOne = step(0.5, Blend);
     Out = result2 * zeroOrOne + (1 - zeroOrOne) * result1;
+    Out = lerp(Base, Out, Opacity);
 }
 ";
         }
             [Slot(1, Binding.None)] DynamicDimensionVector Blend,
+            [Slot(3, Binding.None, 1, 1, 1, 1)] Vector1 Opacity,
             [Slot(2, Binding.None)] out DynamicDimensionVector Out)
         {
             return
     {precision}{slot2dimension} result2 = Blend / (2.0 * (1.0 - Base));
     {precision}{slot2dimension} zeroOrOne = step(0.5, Base);
     Out = result2 * zeroOrOne + (1 - zeroOrOne) * result1;
+    Out = lerp(Base, Out, Opacity);
 }
 ";
         }
             [Slot(1, Binding.None)] DynamicDimensionVector Blend,
+            [Slot(3, Binding.None, 1, 1, 1, 1)] Vector1 Opacity,
             [Slot(2, Binding.None)] out DynamicDimensionVector Out)
         {
             return
+    Out = lerp(Base, Out, Opacity);
 }
 ";
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Artistic/Filter/DitherNode.cs

         }
         static string Unity_Dither(
             [Slot(0, Binding.None)] DynamicDimensionVector In,
-            [Slot(1, Binding.ScreenPosition)] Vector2 UV,
+            [Slot(1, Binding.ScreenPosition)] Vector2 ScreenPosition,
-    {precision}2 uv = (UV.xy / UV.w) * _ScreenParams.xy;
+    {precision}2 uv = ScreenPosition.xy * _ScreenParams.xy;
     {precision} DITHER_THRESHOLDS[16] =
     {
         1.0 / 17.0,  9.0 / 17.0,  3.0 / 17.0, 11.0 / 17.0,

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Artistic/Mask/ColorMaskNode.cs

             [Slot(0, Binding.None)] Vector3 In,
             [Slot(1, Binding.None)] ColorRGB MaskColor,
             [Slot(2, Binding.None)] Vector1 Range,
-            [Slot(3, Binding.None)] out Vector3 Out)
+            [Slot(4, Binding.None)] Vector1 Fuzziness,
+            [Slot(3, Binding.None)] out Vector1 Out)
-            Out = Vector3.zero;
-    {precision}3 col = {precision}3(0, 0, 0);
-    if(Distance <= Range)
-        col = {precision}3(1, 1, 1);
-    Out = col;
+    Out = saturate(1 - (Distance - Range) / max(Fuzziness, 1e-5));
 }";
         }
     }

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

                 case Binding.MeshUV3:
                     return new UVMaterialSlot(slotId, displayName, shaderOutputName, UVChannel.UV3);
                 case Binding.ScreenPosition:
-                    return new ScreenPositionMaterialSlot(slotId, displayName, shaderOutputName);
+                    return new ScreenPositionMaterialSlot(slotId, displayName, shaderOutputName, ScreenSpaceType.Default);
                 case Binding.ObjectSpaceViewDirection:
                     return new ViewDirectionMaterialSlot(slotId, displayName, shaderOutputName, CoordinateSpace.Object);
                 case Binding.ViewSpaceViewDirection:

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

                 if ((value.color == m_Color.color) && (value.mode == m_Color.mode))
                     return;
                 m_Color = value;
-                Dirty(ModificationScope.Graph);
+                Dirty(ModificationScope.Node);
             }
         }
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Geometry/ScreenPositionNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-    public enum ScreenSpaceType
-    {
-        Default,
-        Raw,
-        Center,
-        Tiled
-    };
-
     [Title("Input", "Geometry", "Screen Position")]
     public class ScreenPositionNode : AbstractMaterialNode, IGeneratesBodyCode, IMayRequireScreenPosition
     {
 
         public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
         {
-            switch (m_ScreenSpaceType)
-            {
-                case ScreenSpaceType.Raw:
-                    visitor.AddShaderChunk(string.Format("{0}4 {1} = IN.{2};", precision, GetVariableNameForSlot(kOutputSlotId),
-                        ShaderGeneratorNames.ScreenPosition), true);
-                    break;
-                case ScreenSpaceType.Center:
-                    visitor.AddShaderChunk(string.Format("{0}4 {1} = {2};", precision, GetVariableNameForSlot(kOutputSlotId),
-                        string.Format("float4((IN.{0}.xy / IN.{0}.w) * 2 - 1, 0, 0)", ShaderGeneratorNames.ScreenPosition)), true);
-                    break;
-                case ScreenSpaceType.Tiled:
-                    visitor.AddShaderChunk(string.Format("{0}4 {1} = {2};", precision, GetVariableNameForSlot(kOutputSlotId),
-                        string.Format("float4((IN.{0}.xy / IN.{0}.w) * 2 - 1, 0, 0)", ShaderGeneratorNames.ScreenPosition)), true);
-                    visitor.AddShaderChunk(string.Format("{0} = {1};", GetVariableNameForSlot(kOutputSlotId),
-                        string.Format("frac(float4({0}.x * _ScreenParams.x / _ScreenParams.y, {0}.y, 0, 0))", GetVariableNameForSlot(kOutputSlotId))), true);
-                    break;
-                default:
-                    visitor.AddShaderChunk(string.Format("{0}4 {1} = {2};", precision, GetVariableNameForSlot(kOutputSlotId),
-                        string.Format("float4(IN.{0}.xy / IN.{0}.w, 0, 0)", ShaderGeneratorNames.ScreenPosition)), true);
-                    break;
-            }
+            visitor.AddShaderChunk(string.Format("{0}4 {1} = {2};", precision, GetVariableNameForSlot(kOutputSlotId), m_ScreenSpaceType.ToValueAsVariable()), true);
         }
 
         public bool RequiresScreenPosition()

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Advanced/AbsoluteNode.cs

             name = "Absolute";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Absolute-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Absolute", BindingFlags.Static | BindingFlags.NonPublic);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Advanced/ExponentialNode.cs

             name = "Exponential";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Exponential-Node"; }
+        }
+
         [SerializeField]
         private ExponentialBase m_ExponentialBase = ExponentialBase.BaseE;
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Advanced/LengthNode.cs

             name = "Length";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Length-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Length", BindingFlags.Static | BindingFlags.NonPublic);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Advanced/LogNode.cs

             name = "Log";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Log-Node"; }
+        }
+
         [SerializeField]
         private LogBase m_LogBase = LogBase.BaseE;
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Advanced/ModuloNode.cs

             name = "Modulo";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Modulo-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Modulo", BindingFlags.Static | BindingFlags.NonPublic);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Advanced/NegateNode.cs

             name = "Negate";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Negate-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Negate", BindingFlags.Static | BindingFlags.NonPublic);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Advanced/NormalizeNode.cs

             name = "Normalize";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Normalize-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Normalize", BindingFlags.Static | BindingFlags.NonPublic);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Advanced/PosterizeNode.cs

             name = "Posterize";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Posterize-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Posterize", BindingFlags.Static | BindingFlags.NonPublic);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Advanced/ReciprocalNode.cs

             name = "Reciprocal";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Reciprocal-Node"; }
+        }
+
         [SerializeField]
         private ReciprocalMethod m_ReciprocalMethod = ReciprocalMethod.Default;
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Advanced/ReciprocalSquareRootNode.cs

             name = "Reciprocal Square Root";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Reciprocal-Square-Root-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Rsqrt", BindingFlags.Static | BindingFlags.NonPublic);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Basic/AddNode.cs

             name = "Add";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Add-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Add", BindingFlags.Static | BindingFlags.NonPublic);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Basic/DivideNode.cs

             name = "Divide";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Divide-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Divide", BindingFlags.Static | BindingFlags.NonPublic);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Basic/MultiplyNode.cs

             name = "Multiply";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Multiply-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Multiply", BindingFlags.Static | BindingFlags.NonPublic);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Basic/PowerNode.cs

             name = "Power";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Power-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Power", BindingFlags.Static | BindingFlags.NonPublic);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Basic/SquareRootNode.cs

             name = "Square Root";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Square-Root-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_SquareRoot", BindingFlags.Static | BindingFlags.NonPublic);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Basic/SubtractNode.cs

             name = "Subtract";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Subtract-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Subtract", BindingFlags.Static | BindingFlags.NonPublic);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Range/RandomRangeNode.cs

+using UnityEngine;
 using System.Reflection;
 
 namespace UnityEditor.ShaderGraph
         }
 
         static string Unity_RandomRange(
-            [Slot(0, Binding.None)] Vector1 Seed,
+            [Slot(0, Binding.None)] Vector2 Seed,
             [Slot(1, Binding.None)] Vector1 Min,
             [Slot(2, Binding.None, 1, 1, 1, 1)] Vector1 Max,
             [Slot(3, Binding.None)] out Vector1 Out)
 {
-     {precision} randomno =  frac(sin(dot({precision}2(Seed, Seed), float2(12.9898, 78.233)))*43758.5453);
-     Out = floor(randomno * (Max - Min + 1)) + Min;
+     {precision} randomno =  frac(sin(dot(Seed, float2(12.9898, 78.233)))*43758.5453);
+     Out = lerp(Min, Max, randomno);
 }";
         }
     }

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

 using System;
-using System.Collections.Generic;
 using UnityEditor.Experimental.UIElements.GraphView;
 using UnityEngine;
 using UnityEngine.Experimental.UIElements;
         public Blackboard()
         {
             AddStyleSheetPath("Styles/Blackboard");
-            var tpl = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>("Assets/UnityShaderEditor/Editor/Resources/UXML/GraphView/Blackboard.uxml");
+            var tpl = Resources.Load<VisualTreeAsset>("UXML/GraphView/Blackboard");
 
             m_MainContainer = tpl.CloneTree(null);
             m_MainContainer.AddToClassList("mainContainer");

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Blackboard/BlackboardField.cs

 
         public BlackboardField(Texture icon, string text, string typeText)
         {
-            var tpl = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>("Assets/UnityShaderEditor/Editor/Resources/UXML/GraphView/BlackboardField.uxml");
+            var tpl = Resources.Load<VisualTreeAsset>("UXML/GraphView/BlackboardField");
             VisualElement mainContainer = tpl.CloneTree(null);
 
             mainContainer.AddToClassList("mainContainer");

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Blackboard/BlackboardRow.cs

 
         public BlackboardRow(VisualElement item, VisualElement propertyView)
         {
-            var tpl = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>("Assets/UnityShaderEditor/Editor/Resources/UXML/GraphView/BlackboardRow.uxml") as VisualTreeAsset;
+            var tpl = Resources.Load<VisualTreeAsset>("UXML/GraphView/BlackboardRow");
             VisualElement mainContainer = tpl.CloneTree(null);
             mainContainer.AddToClassList("mainContainer");
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Blackboard/BlackboardSection.cs

 
         public BlackboardSection()
         {
-            var tpl = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>("Assets/UnityShaderEditor/Editor/Resources/UXML/GraphView/BlackboardSection.uxml") as VisualTreeAsset;
+            var tpl = Resources.Load<VisualTreeAsset>("UXML/GraphView/BlackboardSection");
             m_MainContainer = tpl.CloneTree(null);
             m_MainContainer.AddToClassList("mainContainer");
 

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

 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
 using UnityEngine;
 using UnityEditor.Experimental.UIElements;
 using UnityEngine.Experimental.UIElements;
         ObjectField m_PreviewMeshPicker;
 
         MasterNode m_MasterNode;
+        Mesh m_PreviousMesh;
+
+        List<string> m_DoNotShowPrimitives = new List<string>( new string[] {PrimitiveType.Plane.ToString()});
+
+        static Type s_ContextualMenuManipulator = AppDomain.CurrentDomain.GetAssemblies().SelectMany(x => x.GetTypes()).FirstOrDefault(t => t.FullName == "UnityEngine.Experimental.UIElements.ContextualMenuManipulator");
+        static Type s_ObjectSelector = AppDomain.CurrentDomain.GetAssemblies().SelectMany(x => x.GetTypes()).FirstOrDefault(t => t.FullName == "UnityEditor.ObjectSelector");
+            this.clippingOptions = ClippingOptions.ClipAndCacheContents;
             m_Graph = graph;
 
             AddStyleSheetPath("Styles/MaterialGraph");
 
             var topContainer = new VisualElement() { name = "top" };
             {
-                var title = new Label(assetName + " master node preview") { name = "title" };
+                var title = new Label(assetName.Split('/').Last()) { name = "title" };
                 topContainer.Add(title);
             }
             Add(topContainer);
                 m_PreviewTextureView = new PreviewTextureView { name = "preview", image = Texture2D.blackTexture };
-                m_PreviewTextureView.AddManipulator(new Draggable(OnMouseDragPreviwMesh, true));
+                m_PreviewTextureView.AddManipulator(new Draggable(OnMouseDragPreviewMesh, true));
+                m_PreviewTextureView.AddManipulator((IManipulator)Activator.CreateInstance(s_ContextualMenuManipulator, (Action<ContextualMenuPopulateEvent>)BuildContextualMenu));
+
+
+                middleContainer.AddManipulator(new Scrollable(OnScroll));
+        }
-            var bottomContainer = new VisualElement() { name = "bottom" };
-            {
-                m_PreviewMeshPicker = new ObjectField { name = "picker", objectType = typeof(Mesh) };
-                m_PreviewMeshPicker.OnValueChanged(OnPreviewMeshChanged);
+        void OnScroll(float scrollValue)
+        {
+            float rescaleAmount = -scrollValue * .03f;
+            m_Graph.previewData.scale = Mathf.Clamp(m_Graph.previewData.scale + rescaleAmount, 0.2f, 5f);
+        }
-                bottomContainer.Add(m_PreviewMeshPicker);
+        void BuildContextualMenu(ContextualMenuPopulateEvent evt)
+        {
+            foreach (var primitiveTypeName in Enum.GetNames(typeof(PrimitiveType)))
+            {
+                if(m_DoNotShowPrimitives.Contains(primitiveTypeName))
+                    continue;
+                evt.menu.AppendAction(primitiveTypeName, e => ChangePrimitiveMesh( primitiveTypeName ), ContextualMenu.MenuAction.AlwaysEnabled);
-            Add(bottomContainer);
+
+            evt.menu.AppendAction("Custom Mesh", e => ChangeMeshCustom(), ContextualMenu.MenuAction.AlwaysEnabled);
         }
 
         MasterNode masterNode
             m_PreviewTextureView.Dirty(ChangeType.Repaint);
         }
 
-        void OnPreviewMeshChanged(ChangeEvent<Object> changeEvent)
+        void ChangePrimitiveMesh(string primitiveName)
-            Mesh changedMesh = changeEvent.newValue as Mesh;
+            Mesh changedPrimitiveMesh = Resources.GetBuiltinResource(typeof(Mesh), string.Format("{0}.fbx", primitiveName)) as Mesh;
+
+            ChangeMesh(changedPrimitiveMesh);
+        }
+
+        void ChangeMesh(Mesh mesh)
+        {
+            Mesh changedMesh = mesh;
 
             masterNode.Dirty(ModificationScope.Node);
 
             m_Graph.previewData.serializedMesh.mesh = changedMesh;
         }
 
-        void OnMouseDragPreviwMesh(Vector2 deltaMouse)
+        private static EditorWindow Get()
+        {
+            PropertyInfo P = s_ObjectSelector.GetProperty("get", BindingFlags.Public | BindingFlags.Static);
+            return P.GetValue(null,null) as EditorWindow;
+        }
+
+        void OnMeshChanged(Object obj)
+        {
+            var mesh = obj as Mesh;
+            if (mesh == null)
+                mesh = m_PreviousMesh;
+            ChangeMesh(mesh);
+        }
+
+        void ChangeMeshCustom()
+        {
+            MethodInfo ShowMethod = s_ObjectSelector.GetMethod("Show", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly, Type.DefaultBinder, new[] {typeof(Object), typeof(Type), typeof(SerializedProperty), typeof(bool), typeof(List<int>), typeof(Action<Object>), typeof(Action<Object>)}, new ParameterModifier[7]);
+            m_PreviousMesh = m_Graph.previewData.serializedMesh.mesh;
+            ShowMethod.Invoke(Get(), new object[] { null, typeof(Mesh), null, false, null, (Action<Object>)OnMeshChanged, (Action<Object>)OnMeshChanged });
+        }
+
+        public void RefreshRenderTextureSize()
+        {
+            RenderTextureDescriptor descriptor = m_PreviewRenderHandle.renderTexture.descriptor;
+
+            var targetWidth = m_PreviewTextureView.contentRect.width;
+            var targetHeight = m_PreviewTextureView.contentRect.height;
+
+            if (Mathf.Approximately(descriptor.width, targetHeight) && Mathf.Approximately(descriptor.height, targetWidth))
+            {
+                return;
+            }
+
+            descriptor.width = (int)m_PreviewTextureView.contentRect.width;
+            descriptor.height = (int)m_PreviewTextureView.contentRect.height;
+
+            m_PreviewRenderHandle.renderTexture.Release();
+            Object.DestroyImmediate(m_PreviewRenderHandle.renderTexture);
+            m_PreviewRenderHandle.renderTexture = new RenderTexture(descriptor);
+        }
+
+        public void UpdateRenderTextureOnNextLayoutChange()
+        {
+            RegisterCallback<PostLayoutEvent>(AdaptRenderTextureOnLayoutChange);
+        }
+
+        void AdaptRenderTextureOnLayoutChange(PostLayoutEvent evt)
+        {
+            UnregisterCallback<PostLayoutEvent>(AdaptRenderTextureOnLayoutChange);
+            RefreshRenderTextureSize();
+        }
+
+        void OnMouseDragPreviewMesh(Vector2 deltaMouse)
         {
             Vector2 previewSize = m_PreviewTextureView.contentRect.size;
 

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

         set
         {
             m_StayWithinParentBounds = value;
+            foreach (ResizeSideHandle resizeHandle in m_ResizeSideHandles)
+            {
+                resizeHandle.stayWithinParentBounds = value;
+            }
+        }
+    }
+
+    bool m_MaintainApsectRatio;
+    public bool maintainAspectRatio
+    {
+        get { return m_MaintainApsectRatio; }
+        set
+        {
+            m_MaintainApsectRatio = value;
-                resizeHandle.stayWithinPanretBounds = value;
+                resizeHandle.maintainAspectRatio = value;
             }
         }
     }

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

 
         bool m_StayWithinParentBounds;
 
-        public bool stayWithinPanretBounds
+        public bool stayWithinParentBounds
+        }
+
+        bool m_MaintainAspectRatio;
+
+        public bool maintainAspectRatio
+        {
+            get { return m_MaintainAspectRatio; }
+            set { m_MaintainAspectRatio = value; }
         }
 
         public Action OnResizeFinished;
             bool moveWhileResizeHorizontal = anchor == ResizeHandleAnchor.TopLeft || anchor == ResizeHandleAnchor.BottomLeft || anchor == ResizeHandleAnchor.Left;
             bool moveWhileResizeVertical = anchor == ResizeHandleAnchor.TopLeft || anchor == ResizeHandleAnchor.TopRight || anchor == ResizeHandleAnchor.Top;
 
-            this.AddManipulator(new Draggable(mouseDelta => OnResize(mouseDelta, resizeDirection, moveWhileResizeHorizontal, moveWhileResizeVertical)));
+            this.AddManipulator(new Draggable(mouseDelta => OnResize(mouseDelta, resizeDirection, moveWhileResizeHorizontal, moveWhileResizeVertical, anchor)));
-        void OnResize(Vector2 resizeDelta, ResizeDirection direction, bool moveWhileResizeHorizontal, bool moveWhileresizeVertical)
+        void OnResize(Vector2 resizeDelta, ResizeDirection direction, bool moveWhileResizeHorizontal, bool moveWhileresizeVertical, ResizeHandleAnchor anchor)
         {
             Vector2 normalizedResizeDelta = resizeDelta / 2f;
 
 
             Rect newLayout = m_ResizeTarget.layout;
 
-            // Resize from bottom/right
-            if (!moveWhileResizeHorizontal)
+            if (anchor == ResizeHandleAnchor.Left || anchor == ResizeHandleAnchor.TopLeft || anchor == ResizeHandleAnchor.BottomLeft)
-                newLayout.width = Mathf.Max(newLayout.width + normalizedResizeDelta.x, minSize.x);
-                normalizedResizeDelta.x = 0f;
+                newLayout.xMin = Mathf.Min(newLayout.xMin + normalizedResizeDelta.x, newLayout.xMax - minSize.x);
-
-            if (!moveWhileresizeVertical)
+            else
-                newLayout.height = Mathf.Max(newLayout.height + normalizedResizeDelta.y, minSize.y);
-                normalizedResizeDelta.y = 0f;
+                newLayout.xMax = Mathf.Max(newLayout.xMax + normalizedResizeDelta.x, newLayout.xMin + minSize.x);
-            float previousFarX = m_ResizeTarget.layout.x + m_ResizeTarget.layout.width;
-            float previousFarY = m_ResizeTarget.layout.y + m_ResizeTarget.layout.height;
-
-            newLayout.width = Mathf.Max(newLayout.width - normalizedResizeDelta.x, minSize.x);
-            newLayout.height = Mathf.Max(newLayout.height - normalizedResizeDelta.y, minSize.y);
-
-            newLayout.x = Mathf.Min(newLayout.x + normalizedResizeDelta.x, previousFarX - minSize.x);
-            newLayout.y = Mathf.Min(newLayout.y + normalizedResizeDelta.y, previousFarY - minSize.y);
-
-            if (m_StayWithinParentBounds)
+            if (anchor == ResizeHandleAnchor.Top || anchor == ResizeHandleAnchor.TopLeft || anchor == ResizeHandleAnchor.TopRight)
-                float horizontalTranscendance = Mathf.Min(newLayout.x, 0f) + Mathf.Max(newLayout.xMax - m_ResizeTarget.parent.layout.width, 0f);
-                float verticalTranscendance = Mathf.Min(newLayout.y, 0f) + Mathf.Max(newLayout.yMax - m_ResizeTarget.parent.layout.height, 0f);
-
-                if (moveWhileResizeHorizontal)
-                {
-                    newLayout.x -= horizontalTranscendance;
-                }
-                newLayout.width -= Mathf.Abs(horizontalTranscendance);
+                newLayout.yMin = Mathf.Min(newLayout.yMin + normalizedResizeDelta.y, newLayout.yMax - minSize.y);
+            }
+            else
+            {
+                newLayout.yMax = Mathf.Max(newLayout.yMax + normalizedResizeDelta.y, newLayout.yMin + minSize.y);
+            }
-                if (moveWhileresizeVertical)
-                {
-                    newLayout.y -= verticalTranscendance;
-                }
-                newLayout.height -= Mathf.Abs(verticalTranscendance);
+            if (stayWithinParentBounds)
+            {
+                newLayout.xMin = Mathf.Max(newLayout.xMin, 0f);
+                newLayout.yMin = Mathf.Max(newLayout.yMin, 0f);
+                newLayout.xMax = Mathf.Min(newLayout.xMax, m_ResizeTarget.parent.layout.width);
+                newLayout.yMax = Mathf.Min(newLayout.yMax, m_ResizeTarget.parent.layout.height);
             }
 
             m_ResizeTarget.layout = newLayout;

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

             PropagateNodeSet(m_DirtyPreviews);
 
             m_NodesWith3DPreview.Clear();
-            foreach (var index in m_DirtyPreviews)
+            foreach (var node in m_Graph.GetNodes<AbstractMaterialNode>())
-                var node = (AbstractMaterialNode)m_Graph.GetNodeFromTempId(m_Identifiers[index]);
                 if (node.previewMode == PreviewMode.Preview3D)
                     m_NodesWith3DPreview.Add(node.tempId.index);
             }
             {
                 var mesh = m_Graph.previewData.serializedMesh.mesh ? m_Graph.previewData.serializedMesh.mesh :  m_SceneResources.sphere;
                 var previewTransform = Matrix4x4.Rotate(m_Graph.previewData.rotation);
-                previewTransform *= Matrix4x4.Scale(Vector3.one * (Vector3.one).magnitude / mesh.bounds.size.magnitude);
+                var scale = m_Graph.previewData.scale;
+                previewTransform *= Matrix4x4.Scale(scale * Vector3.one * (Vector3.one).magnitude / mesh.bounds.size.magnitude);
                 previewTransform *= Matrix4x4.Translate(-mesh.bounds.center);
                 RenderPreview(masterRenderData, mesh, previewTransform);
             }
 
         void DestroyRenderData(PreviewRenderData renderData)
         {
-            if (renderData.shaderData.shader != null && renderData.shaderData.shader != m_UberShader)
+            if (renderData.shaderData != null
+                && renderData.shaderData.shader != null
+                && renderData.shaderData.shader != m_UberShader)
-            var node = renderData.shaderData.node;
-            if (node != null)
-                node.onModified -= OnNodeModified;
+
+            if (renderData.shaderData != null && renderData.shaderData.node != null)
+                renderData.shaderData.node.onModified -= OnNodeModified;
         }
 
         void DestroyPreview(Identifier nodeId)

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

             var nodeEntries = new List<NodeEntry>();
             foreach (var type in Assembly.GetAssembly(typeof(AbstractMaterialNode)).GetTypes())
             {
-                if (type.IsClass && !type.IsAbstract && (type.IsSubclassOf(typeof(AbstractMaterialNode))))
+                if (type.IsClass && !type.IsAbstract && (type.IsSubclassOf(typeof(AbstractMaterialNode))) && type != typeof(PropertyNode))
                 {
                     var attrs = type.GetCustomAttributes(typeof(TitleAttribute), false) as TitleAttribute[];
                     if (attrs != null && attrs.Length > 0)

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

                 m_GraphView.RegisterCallback<KeyDownEvent>(OnSpaceDown);
                 content.Add(m_GraphView);
 
+                // Uncomment to enable pixel caching profiler
+//                m_ProfilerView = new PixelCacheProfilerView(this);
+//                m_GraphView.Add(m_ProfilerView);
+
                 m_BlackboardProvider = new BlackboardProvider(assetName, graph);
                 m_GraphView.Add(m_BlackboardProvider.blackboard);
                 m_BlackboardProvider.blackboard.layout = new Rect(new Vector2(10f, 10f), m_BlackboardProvider.blackboard.layout.size);
 
                 ResizeBorderFrame masterPreviewResizeBorderFrame = new ResizeBorderFrame(m_MasterPreviewView) { name = "resizeBorderFrame" };
                 masterPreviewResizeBorderFrame.stayWithinParentBounds = true;
+                masterPreviewResizeBorderFrame.maintainAspectRatio = true;
                 masterPreviewResizeBorderFrame.OnResizeFinished += UpdateSerializedWindowLayout;
                 m_MasterPreviewView.Add(masterPreviewResizeBorderFrame);
 
                 Vector2 screenPoint = m_EditorWindow.position.position + referencePosition;
 
                 graphView.nodeCreationRequest(new NodeCreationContext() { screenMousePosition = screenPoint });
+            }
+            else if (evt.keyCode == KeyCode.F1)
+            {
+                if (m_GraphView.selection.OfType<MaterialNodeView>().Count() == 1)
+                {
+                    var nodeView = (MaterialNodeView)graphView.selection.First();
+                    if(nodeView.node.documentationURL != null)
+                        System.Diagnostics.Process.Start(nodeView.node.documentationURL);
+                }
             }
         }
 
                 node.UpdatePortInputVisibilities();
 
             UpdateEdgeColors(nodesToUpdate);
+
+            if (m_ProfilerView != null)
+                m_ProfilerView.Profile();
         }
 
         void AddNode(INode node)
         }
 
         Stack<MaterialNodeView> m_NodeStack = new Stack<MaterialNodeView>();
+        PixelCacheProfilerView m_ProfilerView;
 
         void UpdateEdgeColors(HashSet<MaterialNodeView> nodeViews)
         {
 
                 m_MasterPreviewView.layout = m_FloatingWindowsLayout.previewLayout.GetLayout(layout);
                 m_BlackboardProvider.blackboard.layout = m_FloatingWindowsLayout.blackboardLayout.GetLayout(layout);
+
+                m_MasterPreviewView.UpdateRenderTextureOnNextLayoutChange();
             }
             else
             {
 
             string serializedWindowLayout = JsonUtility.ToJson(m_FloatingWindowsLayout);
             EditorUserSettings.SetConfigValue(m_FloatingWindowsLayoutKey, serializedWindowLayout);
+
+            m_MasterPreviewView.RefreshRenderTextureSize();
-            saveRequested = null;
-            convertToSubgraphRequested = null;
-            showInProjectRequested = null;
+                saveRequested = null;
+                convertToSubgraphRequested = null;
+                showInProjectRequested = null;
                 foreach (var node in m_GraphView.Children().OfType<MaterialNodeView>())
                     node.Dispose();
                 m_GraphView = null;

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

                 evt.menu.AppendAction("Convert To Sub-graph", ConvertToSubgraph, ConvertToSubgraphStatus);
                 evt.menu.AppendAction("Convert To Inline Node", ConvertToInlineNode, ConvertToInlineNodeStatus);
                 evt.menu.AppendAction("Convert To Property", ConvertToProperty, ConvertToPropertyStatus);
+                if (selection.OfType<MaterialNodeView>().Count() == 1)
+                {
+                    evt.menu.AppendSeparator();
+                    evt.menu.AppendAction("Open Documentation", SeeDocumentation, SeeDocumentationStatus);
+                }
+            if (evt.target is MaterialGraphView)
+            {
+                evt.menu.AppendAction("Collapse Previews", CollapsePreviews, ContextualMenu.MenuAction.AlwaysEnabled);
+                evt.menu.AppendAction("Expand Previews", ExpandPreviews, ContextualMenu.MenuAction.AlwaysEnabled);
+                evt.menu.AppendSeparator();
+            }
+        }
+
+        void CollapsePreviews(EventBase evt)
+        {
+            graph.owner.RegisterCompleteObjectUndo("Collapse Previews");
+            foreach (AbstractMaterialNode node in graph.GetNodes<AbstractMaterialNode>())
+            {
+                node.previewExpanded = false;
+            }
+        }
+
+        void ExpandPreviews(EventBase evt)
+        {
+            graph.owner.RegisterCompleteObjectUndo("Expand Previews");
+            foreach (AbstractMaterialNode node in graph.GetNodes<AbstractMaterialNode>())
+            {
+                node.previewExpanded = true;
+            }
+        }
+
+        void SeeDocumentation(EventBase evt)
+        {
+            var node = selection.OfType<MaterialNodeView>().First().node;
+            if (node.documentationURL != null)
+                System.Diagnostics.Process.Start(node.documentationURL);
+        }
+
+        ContextualMenu.MenuAction.StatusFlags SeeDocumentationStatus(EventBase eventBase)
+        {
+            if (selection.OfType<MaterialNodeView>().First().node.documentationURL == null)
+                return ContextualMenu.MenuAction.StatusFlags.Disabled;
+            return ContextualMenu.MenuAction.StatusFlags.Normal;
         }
 
         ContextualMenu.MenuAction.StatusFlags ConvertToPropertyStatus(EventBase eventBase)
                     graph.RemoveShaderProperty(property.guid);
                 }
             }
+            selection.Clear();
         }
 
         public bool CanAcceptDrop(List<ISelectable> selection)

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

 using UnityEngine.Experimental.UIElements;
 using UnityEditor.Graphing;
 using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEngine.Experimental.UIElements.StyleEnums;
 using Node = UnityEditor.Experimental.UIElements.GraphView.Node;
 
 namespace UnityEditor.ShaderGraph.Drawing
-        List<VisualElement> m_ControlViews;
-        PreviewTextureView m_PreviewTextureView;
-        VisualElement m_ControlsContainer;
+        Image m_PreviewImage;
-        List<Attacher> m_Attachers;
+        VisualElement m_ControlItems;
+        VisualElement m_PreviewFiller;
+        VisualElement m_PortInputContainer;
 
         public void Initialize(AbstractMaterialNode inNode, PreviewManager previewManager, IEdgeConnectorListener connectorListener)
         {
                 return;
 
+            var contents = this.Q("contents");
+
-            m_ControlsContainer = new VisualElement
+            // Add controls container
+            var controlsContainer = new VisualElement { name = "controls" };
-                name = "controls"
-            };
-            extensionContainer.Add(m_ControlsContainer);
-            m_ControlsDivider = new VisualElement { name = "divider" };
-            m_ControlsDivider.AddToClassList("horizontal");
+                m_ControlsDivider = new VisualElement { name = "divider" };
+                m_ControlsDivider.AddToClassList("horizontal");
+                controlsContainer.Add(m_ControlsDivider);
+                m_ControlItems = new VisualElement { name = "items" };
+                controlsContainer.Add(m_ControlItems);
+
+                // Instantiate control views from node
+                foreach (var propertyInfo in node.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
+                foreach (IControlAttribute attribute in propertyInfo.GetCustomAttributes(typeof(IControlAttribute), false))
+                    m_ControlItems.Add(attribute.InstantiateControl(node, propertyInfo));
+            }
+            if (m_ControlItems.childCount > 0)
+                contents.Add(controlsContainer);
-                m_PreviewContainer = new VisualElement { name = "previewContainer" };
-                m_PreviewContainer.AddToClassList("expanded");
+                // Add actual preview which floats on top of the node
+                m_PreviewContainer = new VisualElement
-                    m_PreviewTextureView = new PreviewTextureView
-                    {
-                        name = "preview",
-                        pickingMode = PickingMode.Ignore,
-                        image = Texture2D.whiteTexture
-                    };
-                    m_PreviewRenderData = previewManager.GetPreview(inNode);
-                    m_PreviewRenderData.onPreviewChanged += UpdatePreviewTexture;
-                    UpdatePreviewTexture();
-
+                    name = "previewContainer",
+                    clippingOptions = ClippingOptions.ClipAndCacheContents,
+                    pickingMode = PickingMode.Ignore
+                };
+                m_PreviewImage = new Image
+                {
+                    name = "preview",
+                    pickingMode = PickingMode.Ignore,
+                    image = Texture2D.whiteTexture,
+                };
+                {
+                    // Add preview collapse button on top of preview
                     var collapsePreviewButton = new VisualElement { name = "collapse" };
                     collapsePreviewButton.Add(new VisualElement { name = "icon" });
                     collapsePreviewButton.AddManipulator(new Clickable(() =>
                     }));
-                    UpdatePreviewExpandedState(node.previewExpanded);
-                    m_PreviewTextureView.Add(collapsePreviewButton);
+                    m_PreviewImage.Add(collapsePreviewButton);
+                }
+                m_PreviewContainer.Add(m_PreviewImage);
+
+                // Hook up preview image to preview manager
+                m_PreviewRenderData = previewManager.GetPreview(inNode);
+                m_PreviewRenderData.onPreviewChanged += UpdatePreviewTexture;
+                UpdatePreviewTexture();
+
+                // Add fake preview which pads out the node to provide space for the floating preview
+                m_PreviewFiller = new VisualElement { name = "previewFiller" };
+                m_PreviewFiller.AddToClassList("expanded");
+                {
+                    var previewDivider = new VisualElement { name = "divider" };
+                    previewDivider.AddToClassList("horizontal");
+                    m_PreviewFiller.Add(previewDivider);
 
                     var expandPreviewButton = new VisualElement { name = "expand" };
                     expandPreviewButton.Add(new VisualElement { name = "icon" });
                         UpdatePreviewExpandedState(true);
                     }));
-                    m_PreviewContainer.Add(expandPreviewButton);
+                    m_PreviewFiller.Add(expandPreviewButton);
+                contents.Add(m_PreviewFiller);
-                extensionContainer.Add(m_PreviewContainer);
+                UpdatePreviewExpandedState(node.previewExpanded);
-            m_ControlViews = new List<VisualElement>();
-            foreach (var propertyInfo in node.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
-            foreach (IControlAttribute attribute in propertyInfo.GetCustomAttributes(typeof(IControlAttribute), false))
-                m_ControlViews.Add(attribute.InstantiateControl(node, propertyInfo));
-            m_Attachers = new List<Attacher>(node.GetInputSlots<MaterialSlot>().Count());
+            // Add port input container, which acts as a pixel cache for all port inputs
+            m_PortInputContainer = new VisualElement
+            {
+                name = "portInputContainer",
+                clippingOptions = ClippingOptions.ClipAndCacheContents,
+                pickingMode = PickingMode.Ignore
+            };
+            Add(m_PortInputContainer);
-            UpdateSlotAttachers();
+            UpdatePortInputs();
-            UpdateControls();
 
             if (node is PreviewNode)
             {
                 UpdateSize();
             }
+
+            m_PortInputContainer.SendToBack();
+            if (node.hasPreview)
+                m_PreviewFiller.BringToFront();
         }
 
         public AbstractMaterialNode node { get; private set; }
                     node.drawState = ds;
                 }
 
-                UpdateControls();
+                RefreshExpandedState(); //This should not be needed. GraphView needs to improve the extension api here
-                RefreshExpandedState(); //This should not be needed. GraphView needs to improve the extension api here
+                if (node.hasPreview)
+                    m_PreviewFiller.BringToFront();
             }
         }
 
         void UpdatePreviewExpandedState(bool expanded)
         {
             node.previewExpanded = expanded;
-            if (m_PreviewContainer == null)
+            if (m_PreviewFiller == null)
-                if (m_PreviewTextureView.parent != m_PreviewContainer)
+                if (m_PreviewContainer.parent != this)
-                    m_PreviewContainer.Add(m_PreviewTextureView);
+                    Add(m_PreviewContainer);
-                m_PreviewContainer.AddToClassList("expanded");
-                m_PreviewContainer.RemoveFromClassList("collapsed");
+                m_PreviewFiller.AddToClassList("expanded");
+                m_PreviewFiller.RemoveFromClassList("collapsed");
-                if (m_PreviewTextureView.parent == m_PreviewContainer)
+                if (m_PreviewContainer.parent == m_PreviewFiller)
-                    m_PreviewTextureView.RemoveFromHierarchy();
+                    m_PreviewContainer.RemoveFromHierarchy();
-                m_PreviewContainer.RemoveFromClassList("expanded");
-                m_PreviewContainer.AddToClassList("collapsed");
+                m_PreviewFiller.RemoveFromClassList("expanded");
+                m_PreviewFiller.AddToClassList("collapsed");
             }
         }
 
                         // Slot doesn't exist anymore, remove it
                         inputContainer.Remove(port);
 
-                        // We also need to remove the attacher along with the element it's attaching
-                        var attacher = m_Attachers.FirstOrDefault(a => a.target == port);
-                        if (attacher != null)
-                        {
-                            attacher.Detach();
-                            attacher.element.parent.Remove(attacher.element);
-                            m_Attachers.Remove(attacher);
-                        }
+                        // We also need to remove the inline input
+                        var portInputView = m_PortInputContainer.OfType<PortInputView>().FirstOrDefault(v => Equals(v.slot, port.slot));
+                        if (portInputView != null)
+                            portInputView.RemoveFromHierarchy();
                     }
                     else
                     {
                     outputContainer.Sort((x, y) => slots.IndexOf(((ShaderPort)x).slot) - slots.IndexOf(((ShaderPort)y).slot));
             }
 
-            UpdateControls();
-            UpdateSlotAttachers();
+            UpdatePortInputs();
-            foreach (var control in m_ControlViews)
+            foreach (var control in m_ControlItems)
             {
                 var listener = control as INodeModificationListener;
                 if (listener != null)
             }
         }
 
-        void UpdateSlotAttachers()
+        void UpdatePortInputs()
-                if (!m_Attachers.Any(a => a.target == port))
+                if (!m_PortInputContainer.OfType<PortInputView>().Any(a => Equals(a.slot, port.slot)))
-                    var portInputView = new PortInputView(port.slot);
-                    Add(portInputView);
-                    mainContainer.BringToFront();
-                    m_Attachers.Add(new Attacher(portInputView, port, SpriteAlignment.LeftCenter) { distance = -8f });
+                    var portInputView = new PortInputView(port.slot) { style = { positionType = PositionType.Absolute } };
+                    m_PortInputContainer.Add(portInputView);
+                    port.RegisterCallback<PostLayoutEvent>(evt => UpdatePortInput((ShaderPort)evt.target));
+        void UpdatePortInput(ShaderPort port)
+        {
+            var inputView = m_PortInputContainer.OfType<PortInputView>().First(x => Equals(x.slot, port.slot));
+
+            var currentRect = new Rect(inputView.style.positionLeft, inputView.style.positionTop, inputView.style.width, inputView.style.height);
+            var targetRect = new Rect(0.0f, 0.0f, port.layout.width, port.layout.height);
+            targetRect = port.ChangeCoordinatesTo(inputView.shadow.parent, targetRect);
+            var centerY = targetRect.center.y;
+            var centerX = targetRect.xMax - currentRect.width;
+            currentRect.center = new Vector2(centerX, centerY);
+
+            inputView.style.positionTop = currentRect.yMin;
+            var newHeight = inputView.parent.layout.height;
+            foreach (var element in inputView.parent.Children())
+                newHeight = Mathf.Max(newHeight, element.style.positionTop + element.layout.height);
+            if (Math.Abs(inputView.parent.style.height - newHeight) > 1e-3)
+                inputView.parent.style.height = newHeight;
+        }
+
-            foreach (var attacher in m_Attachers)
+            foreach (var portInputView in m_PortInputContainer.OfType<PortInputView>())
-                var slot = ((ShaderPort)attacher.target).slot;
-                attacher.element.visible = expanded && !node.owner.GetEdges(node.GetSlotReference(slot.id)).Any();
+                var slot = portInputView.slot;
+                var oldVisibility = portInputView.visible;
+                portInputView.visible = expanded && !node.owner.GetEdges(node.GetSlotReference(slot.id)).Any();
+                if (portInputView.visible != oldVisibility)
+                    m_PortInputContainer.Dirty(ChangeType.Repaint);
             }
         }
 
                 anchor.visualClass = slot.concreteValueType.ToClassName();
             }
 
-            foreach (var attacher in m_Attachers)
-            {
-                var portInputView = (PortInputView)attacher.element;
+            foreach (var portInputView in m_PortInputContainer.OfType<PortInputView>())
-            }
-            var updatedHeight = m_PreviewTextureView.layout.height + deltaSize.y;
+            var updatedHeight = m_PreviewImage.layout.height + deltaSize.y;
 
             var previewNode = node as PreviewNode;
             if (previewNode != null)
         {
             if (m_PreviewRenderData.texture == null || !node.previewExpanded)
             {
-                m_PreviewTextureView.visible = false;
-                m_PreviewTextureView.image = Texture2D.blackTexture;
+                m_PreviewImage.visible = false;
+                m_PreviewImage.image = Texture2D.blackTexture;
-                m_PreviewTextureView.visible = true;
-                m_PreviewTextureView.AddToClassList("visible");
-                m_PreviewTextureView.RemoveFromClassList("hidden");
-                if (m_PreviewTextureView.image != m_PreviewRenderData.texture)
-                    m_PreviewTextureView.image = m_PreviewRenderData.texture;
+                m_PreviewImage.visible = true;
+                m_PreviewImage.AddToClassList("visible");
+                m_PreviewImage.RemoveFromClassList("hidden");
+                if (m_PreviewImage.image != m_PreviewRenderData.texture)
+                    m_PreviewImage.image = m_PreviewRenderData.texture;
-                    m_PreviewTextureView.Dirty(ChangeType.Repaint);
+                    m_PreviewImage.Dirty(ChangeType.Repaint);
-        void UpdateControls()
-        {
-            if (!expanded)
-            {
-                m_ControlsContainer.Clear();
-                m_ControlsDivider.RemoveFromHierarchy();
-            }
-            else if (m_ControlsContainer.childCount != m_ControlViews.Count)
-            {
-                m_ControlsContainer.Clear();
-                foreach (var view in m_ControlViews)
-                    m_ControlsContainer.Add(view);
-                extensionContainer.Add(m_ControlsDivider);
-                if (m_PreviewContainer != null)
-                    m_ControlsDivider.PlaceBehind(m_PreviewContainer);
-            }
-
-            if (m_ControlsContainer.childCount == 0)
-                m_ControlsContainer.RemoveFromClassList("notEmpty");
-            else
-                m_ControlsContainer.AddToClassList("notEmpty");
-        }
-
         void UpdateSize()
         {
             var previewNode = node as PreviewNode;
             var width = previewNode.width;
             var height = previewNode.height;
 
-            m_PreviewTextureView.style.height = height;
+            m_PreviewImage.style.height = height;
+            m_PreviewImage.style.width = width;
-            foreach (var attacher in m_Attachers)
-            {
-                ((PortInputView)attacher.element).Dispose();
-                attacher.Detach();
-                attacher.element.parent.Remove(attacher.element);
-            }
-            m_Attachers.Clear();
+            foreach (var portInputView in m_PortInputContainer.OfType<PortInputView>())
+                portInputView.Dispose();
 
             node = null;
             if (m_PreviewRenderData != null)

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

             get { return m_EdgeColor.GetSpecifiedValueOrDefault(Color.red); }
         }
 
+        public MaterialSlot slot
+        {
+            get { return m_Slot; }
+        }
+
         MaterialSlot m_Slot;
         ConcreteSlotValueType m_SlotType;
         VisualElement m_Control;
 
             m_Container = new VisualElement { name = "container" };
             {
-                m_Control = m_Slot.InstantiateControl();
+                m_Control = this.slot.InstantiateControl();
                 if (m_Control != null)
                     m_Container.Add(m_Control);
 
             Add(m_Container);
 
             m_Container.visible = m_EdgeControl.visible = m_Control != null;
-            m_Container.clippingOptions = ClippingOptions.ClipAndCacheContents;
         }
 
         protected override void OnStyleResolved(ICustomStyle styles)
 
         public void UpdateSlotType()
         {
-            if (m_Slot.concreteValueType != m_SlotType)
+            if (slot.concreteValueType != m_SlotType)
-                m_SlotType = m_Slot.concreteValueType;
+                m_SlotType = slot.concreteValueType;
                 AddToClassList("type" + m_SlotType);
                 if (m_Control != null)
                 {
                     m_Container.Remove(m_Control);
                 }
-                m_Control = m_Slot.InstantiateControl();
+                m_Control = slot.InstantiateControl();
                 if (m_Control != null)
                     m_Container.Insert(0, m_Control);
 

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

 using UnityEditor.Experimental.AssetImporters;
 using UnityEditor.ShaderGraph.Drawing;
 
-[ScriptedImporter(10, ShaderGraphImporter.ShaderGraphExtension)]
+[ScriptedImporter(11, ShaderGraphImporter.ShaderGraphExtension)]
 public class ShaderGraphImporter : ScriptedImporter
 {
     public const string ShaderGraphExtension = "shadergraph";
         var text = GetShaderText<MaterialGraph>(ctx.assetPath, out configuredTextures);
         if (text == null)
             text = errorShader;
-        
+
         var name = Path.GetFileNameWithoutExtension(ctx.assetPath);
         string shaderName = string.Format("graphs/{0}", name);
         text = text.Replace("Hidden/GraphErrorShader2", shaderName);
         }
         RegisterShaders(importedAssets);
     }
-}
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Resources/Styles/MaterialGraph.uss

     margin-right: 0;
 }
 
-MaterialNodeView #previewContainer,
+MaterialNodeView #collapsible-area {
+    width: 0;
+    height: 0;
+}
+
+MaterialNodeView #previewFiller.expanded {
+    width: 200;
+    padding-bottom: 200;
+}
+
+MaterialNodeView #previewFiller,
-MaterialNodeView #controls.notEmpty {
+MaterialNodeView #controls > #items {
-MaterialNodeView #previewContainer > #preview  {
+MaterialNodeView > #previewContainer {
+    position-type: absolute;
+    position-bottom: 4;
+    position-left: 4;
+    border-radius: 6;
+    padding-top: 6;
+}
+
+MaterialNodeView > #previewContainer > #preview  {
-MaterialNodeView #previewContainer > #preview > #collapse {
+MaterialNodeView > #previewContainer > #preview > #collapse {
     background-color: #000;
     border-color: #F0F0F0;
     width: 0;
 }
 
 
-MaterialNodeView #previewContainer:hover > #preview > #collapse {
+MaterialNodeView:hover > #previewContainer > #preview > #collapse {
-MaterialNodeView #previewContainer > #preview > #collapse > #icon
-{
+MaterialNodeView > #previewContainer > #preview > #collapse > #icon  {
-MaterialNodeView #previewContainer > #preview > #collapse:hover {
+
+MaterialNodeView > #previewContainer > #preview > #collapse:hover {
-MaterialNodeView #previewContainer.collapsed > #preview > #collapse {
-    height: 0;
-}
-
-MaterialNodeView #previewContainer > #expand {
+MaterialNodeView #previewFiller > #expand {
     align-self: center;
     width: 56;
     height: 16;
 
-MaterialNodeView #previewContainer > #expand > #icon {
+MaterialNodeView #previewFiller > #expand > #icon {
     align-self: center;
     background-image : resource("GraphView/Nodes/PreviewExpand.png");
     width: 16;
-MaterialNodeView #previewContainer.collapsed > #expand:hover {
+MaterialNodeView #previewFiller.collapsed > #expand:hover {
-MaterialNodeView #previewContainer.expanded > #expand {
+MaterialNodeView #previewFiller.expanded > #expand {
     height: 0;
 }
 
     width: 10;
     height: 10;
     cursor: resize-up-left;
+}
+
+MaterialNodeView > #portInputContainer {
+    position-type: absolute;
+    width: 212;
+    position-left: -200;
+    position-top: 46;
 }
 
 PortInputView {
     width: 40;
 }
 
+ScreenPositionSlotControlView > EnumField {
+    margin-top: 0;
+    margin-bottom: 0;
+    margin-left: 0;
+    margin-right: 0;
+    width: 54;
+}
+
 ColorRGBASlotControlView {
     flex-direction: row;
     align-items: center;
     justify-content: flex-start;
     min-width: 200;
     min-height: 200;
-}
+    border-radius: 6;
+    border-top-width: 1;
+    border-bottom-width: 1;
+    border-left-width: 1;
+    border-right-width: 1;
+    border-color: rgb(25,25,25);
-MasterPreviewView > #top {
-    background-color: rgb(64, 64, 64);
-}
-
-MasterPreviewView > #top > #title {
-    font-style: bold;
-    font-size: 11;
+    background-color: rgb(64, 64, 64);
+    border-top-left-radius: 6;
+    border-top-right-radius: 6;
+}
+
+MasterPreviewView > #top > #title {
+    font-size: 12;
+    text-color: rgb(180, 180, 180);
+    padding-top: 1;
+    padding-bottom: 2;
+    padding-left: 2;
+    padding-right: 2;
+    border-width: 10;
-    margin-bottom: 40;
+    border-color: rgb(0,10,190);
-}
-
-MasterPreviewView > #bottom {
-    background-color: rgb(79, 79, 79);
-    position-type: absolute;
-    position-bottom: 0;
-    position-left: 0;
-    position-right: 0;
-    padding-left: 10;
-    padding-right: 10;
-    padding-top: 8;
-    padding-bottom: 12;
-}
-
-MasterPreviewView > #bottom > #picker > ObjectFieldDisplay > Label {
-    font-size: 11;
+    border-width: 10;
+    border-color: rgb(200,10,190);
 }
 
 #resizeBorderFrame > .resize {

MaterialGraphProject/Assets/UnityShaderEditor/package.json

 {
     "name": "com.unity.shadergraph",
     "description": "Shader Graph",
-    "version": "0.1.14",
+    "version": "0.1.17",
-}
+}

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

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

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

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

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

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

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Procedural/Noise/GradientNoiseNode.cs

+using System.Reflection;
+using UnityEngine;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Procedural", "Noise", "Gradient Noise")]
+    public class GradientNoiseNode : CodeFunctionNode
+    {
+        public GradientNoiseNode()
+        {
+            name = "Gradient Noise";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_GradientNoise", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_GradientNoise(
+            [Slot(0, Binding.MeshUV0)] Vector2 UV,
+            [Slot(1, Binding.None, 10, 10, 10, 10)] Vector1 Scale,
+            [Slot(2, Binding.None)] out Vector1 Out)
+        {
+            return "{ Out = unity_gradientNoise(UV * Scale) + 0.5; }";
+        }
+
+        public override void GenerateNodeFunction(FunctionRegistry registry, GenerationMode generationMode)
+        {
+            registry.ProvideFunction("unity_gradientNoise_dir", s => s.Append(@"
+float2 unity_gradientNoise_dir(float2 p)
+{
+    // Permutation and hashing used in webgl-nosie goo.gl/pX7HtC
+    p = p % 289;
+    float x = (34 * p.x + 1) * p.x % 289 + p.y;
+    x = (34 * x + 1) * x % 289;
+    x = frac(x / 41) * 2 - 1;
+    return normalize(float2(x - floor(x + 0.5), abs(x) - 0.5));
+}
+"));
+
+            registry.ProvideFunction("unity_gradientNoise", s => s.Append(@"
+float unity_gradientNoise(float2 p)
+{
+    float2 ip = floor(p);
+    float2 fp = frac(p);
+    float d00 = dot(unity_gradientNoise_dir(ip), fp);
+    float d01 = dot(unity_gradientNoise_dir(ip + float2(0, 1)), fp - float2(0, 1));
+    float d10 = dot(unity_gradientNoise_dir(ip + float2(1, 0)), fp - float2(1, 0));
+    float d11 = dot(unity_gradientNoise_dir(ip + float2(1, 1)), fp - float2(1, 1));
+    fp = fp * fp * fp * (fp * (fp * 6 - 15) + 10);
+    return lerp(lerp(d00, d01, fp.y), lerp(d10, d11, fp.y), fp.x);
+}
+"));
+
+            base.GenerateNodeFunction(registry, generationMode);
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Procedural/Noise/GradientNoiseNode.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Util/ScreenSpaceType.cs

+namespace UnityEditor.ShaderGraph
+{
+    public enum ScreenSpaceType
+    {
+        Default,
+        Raw,
+        Center,
+        Tiled
+    };
+
+    public static class ScreenSpaceTypeExtensions
+    {
+        public static string ToValueAsVariable(this ScreenSpaceType screenSpaceType)
+        {
+            switch (screenSpaceType)
+            {
+                case ScreenSpaceType.Raw:
+                    return string.Format("IN.{0}", ShaderGeneratorNames.ScreenPosition);
+                case ScreenSpaceType.Center:
+                    return string.Format("float4(IN.{0}.xy / IN.{0}.w * 2 - 1, 0, 0)", ShaderGeneratorNames.ScreenPosition);
+                case ScreenSpaceType.Tiled:
+                    return string.Format("frac(float4((IN.{0}.x / IN.{0}.w * 2 - 1) * _ScreenParams.x / _ScreenParams.y, IN.{0}.y / IN.{0}.w * 2 - 1, 0, 0))", ShaderGeneratorNames.ScreenPosition);
+                default:
+                    return string.Format("float4(IN.{0}.xy / IN.{0}.w, 0, 0)", ShaderGeneratorNames.ScreenPosition);
+            }
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Util/ScreenSpaceType.cs.meta

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

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

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Experimental.UIElements;
+using System;
+
+namespace UnityEditor.ShaderGraph.Drawing
+{
+    public class Scrollable : MouseManipulator
+    {
+        Action<float> m_Handler;
+
+        public Scrollable(Action<float> handler)
+        {
+            m_Handler = handler;
+        }
+
+        protected override void RegisterCallbacksOnTarget()
+        {
+            target.RegisterCallback<WheelEvent>(HandleMouseWheelEvent);
+        }
+
+        protected override void UnregisterCallbacksFromTarget()
+        {
+            target.UnregisterCallback<WheelEvent>(HandleMouseWheelEvent);
+        }
+
+        void HandleMouseWheelEvent(WheelEvent evt)
+        {
+            m_Handler(evt.delta.y);
+            evt.StopPropagation();
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Manipulators/Scrollable.cs.meta

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

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

+using System.Linq;
+using UnityEngine;
+using UnityEngine.Experimental.UIElements;
+
+namespace UnityEditor.ShaderGraph.Drawing
+{
+    public class PixelCacheProfilerView : VisualElement
+    {
+        readonly VisualElement m_Target;
+        Label m_TotalLabel;
+        Label m_DirtyLabel;
+        Label m_TotalNodeContentsLabel;
+        Label m_DirtyNodeContentsLabel;
+        Label m_TotalPreviewsLabel;
+        Label m_DirtyPreviewsLabel;
+        Label m_TotalInlinesLabel;
+        Label m_DirtyInlinesLabel;
+
+        public PixelCacheProfilerView(VisualElement target)
+        {
+            m_Target = target;
+
+            var tpl = Resources.Load<VisualTreeAsset>("UXML/PixelCacheProfiler");
+            tpl.CloneTree(this, null);
+
+            m_TotalLabel = this.Q<Label>("totalLabel");
+            m_DirtyLabel = this.Q<Label>("dirtyLabel");
+            m_TotalNodeContentsLabel = this.Q<Label>("totalNodeContentsLabel");
+            m_DirtyNodeContentsLabel = this.Q<Label>("dirtyNodeContentsLabel");
+            m_TotalPreviewsLabel = this.Q<Label>("totalPreviewsLabel");
+            m_DirtyPreviewsLabel = this.Q<Label>("dirtyPreviewsLabel");
+            m_TotalInlinesLabel = this.Q<Label>("totalInlinesLabel");
+            m_DirtyInlinesLabel = this.Q<Label>("dirtyInlinesLabel");
+        }
+
+        public void Profile()
+        {
+            var caches = m_Target.Query().Where(ve => ve.clippingOptions == ClippingOptions.ClipAndCacheContents).Build().ToList();
+            var dirtyCaches = caches.Where(ve => ve.IsDirty(ChangeType.Repaint)).ToList();
+            m_TotalLabel.text = caches.Count.ToString();
+            m_DirtyLabel.text = dirtyCaches.Count.ToString();
+
+            var nodeContentsCaches = caches.Where(ve => ve.name == "node-border").ToList();
+            var dirtyNodeContentsCaches = nodeContentsCaches.Where(ve => ve.IsDirty(ChangeType.Repaint)).ToList();
+            m_TotalNodeContentsLabel.text = nodeContentsCaches.Count.ToString();
+            m_DirtyNodeContentsLabel.text = dirtyNodeContentsCaches.Count.ToString();
+
+            var previewCaches = caches.Where(ve => ve.name == "previewContainer").ToList();
+            var dirtyPreviewCaches = previewCaches.Where(ve => ve.IsDirty(ChangeType.Repaint)).ToList();
+            m_TotalPreviewsLabel.text = previewCaches.Count.ToString();
+            m_DirtyPreviewsLabel.text = dirtyPreviewCaches.Count.ToString();
+
+            var inlineCaches = caches.Where(ve => ve.name == "portInputContainer").ToList();
+            var dirtyInlineCaches = inlineCaches.Where(ve => ve.IsDirty(ChangeType.Repaint)).ToList();
+            m_TotalInlinesLabel.text = inlineCaches.Count.ToString();
+            m_DirtyInlinesLabel.text = dirtyInlineCaches.Count.ToString();
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Views/PixelCacheProfilerView.cs.meta

+fileFormatVersion: 2
+guid: 7147f25b12dd4427b4c8afd44624f35b
+timeCreated: 1517227822

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Views/Slots/ScreenPositionSlotControlView.cs

+using System;
+using UnityEditor.Graphing;
+using UnityEditor.Experimental.UIElements;
+using UnityEngine.Experimental.UIElements;
+
+namespace UnityEditor.ShaderGraph.Drawing.Slots
+{
+    public class ScreenPositionSlotControlView : VisualElement
+    {
+        ScreenPositionMaterialSlot m_Slot;
+
+        public ScreenPositionSlotControlView(ScreenPositionMaterialSlot slot)
+        {
+            m_Slot = slot;
+            var enumField = new EnumField(slot.screenSpaceType);
+            enumField.OnValueChanged(OnValueChanged);
+            Add(enumField);
+        }
+
+        void OnValueChanged(ChangeEvent<Enum> evt)
+        {
+            var screenSpaceType = (ScreenSpaceType)evt.newValue;
+            if (screenSpaceType != m_Slot.screenSpaceType)
+            {
+                m_Slot.owner.owner.owner.RegisterCompleteObjectUndo("Change Screen Space Type");
+                m_Slot.screenSpaceType = screenSpaceType;
+                m_Slot.owner.Dirty(ModificationScope.Graph);
+            }
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Views/Slots/ScreenPositionSlotControlView.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Resources/Styles/PixelCacheProfiler.uss

+PixelCacheProfilerView > #content > #title {
+    font-style: bold;
+}
+
+PixelCacheProfilerView > #content > .row {
+    flex-direction: row;
+}
+
+PixelCacheProfilerView > #content > .indented {
+    padding-left: 8;
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Resources/Styles/PixelCacheProfiler.uss.meta

+fileFormatVersion: 2
+guid: 61cf67e9c1f54ceab08d2bd16ffd3c53
+ScriptedImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Resources/UXML/PixelCacheProfiler.uxml

+<UXML xmlns:ui="UnityEngine.Experimental.UIElements">
+    <ui:VisualElement name="content">
+        <Style path="Styles/PixelCacheProfiler"/>
+        <ui:Label name="title" text="Pixel Cache Profiler"/>
+        <ui:VisualElement class="row">
+            <ui:Label text="Total pixel caches: "/>
+            <ui:Label name="totalLabel" text="-"/>
+        </ui:VisualElement>
+        <ui:VisualElement class="indented row">
+            <ui:Label text="Node contents: "/>
+            <ui:Label name="totalNodeContentsLabel" text="-"/>
+        </ui:VisualElement>
+        <ui:VisualElement class="indented row">
+            <ui:Label text="Node previews: "/>
+            <ui:Label name="totalPreviewsLabel" text="-"/>
+        </ui:VisualElement>
+        <ui:VisualElement class="indented row">
+            <ui:Label text="Inline inputs: "/>
+            <ui:Label name="totalInlinesLabel" text="-"/>
+        </ui:VisualElement>
+
+        <ui:VisualElement class="row">
+            <ui:Label text="Dirty pixel caches: "/>
+            <ui:Label name="dirtyLabel" text="-"/>
+        </ui:VisualElement>
+        <ui:VisualElement class="indented row">
+            <ui:Label text="Node contents: "/>
+            <ui:Label name="dirtyNodeContentsLabel" text="-"/>
+        </ui:VisualElement>
+        <ui:VisualElement class="indented row">
+            <ui:Label text="Node previews: "/>
+            <ui:Label name="dirtyPreviewsLabel" text="-"/>
+        </ui:VisualElement>
+        <ui:VisualElement class="indented row">
+            <ui:Label text="Inline inputs: "/>
+            <ui:Label name="dirtyInlinesLabel" text="-"/>
+        </ui:VisualElement>
+    </ui:VisualElement>
+</UXML>

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Resources/UXML/PixelCacheProfiler.uxml.meta

+fileFormatVersion: 2
+guid: 0fda1aff5a5744478f70542e95fd3d42
+ScriptedImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}

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

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