diff --git a/com.unity.render-pipelines.high-definition/Editor/Material/Decal/ShaderGraph/DecalMasterNode.cs b/com.unity.render-pipelines.high-definition/Editor/Material/Decal/ShaderGraph/DecalMasterNode.cs
index f57e44a8859..eafd241cb0d 100644
--- a/com.unity.render-pipelines.high-definition/Editor/Material/Decal/ShaderGraph/DecalMasterNode.cs
+++ b/com.unity.render-pipelines.high-definition/Editor/Material/Decal/ShaderGraph/DecalMasterNode.cs
@@ -17,7 +17,7 @@ namespace UnityEditor.Rendering.HighDefinition
     [Serializable]
     [Title("Master", "Decal (HDRP)")]
     [FormerName("UnityEditor.Experimental.Rendering.HDPipeline.DecalMasterNode")]
-    class DecalMasterNode : AbstractMaterialNode, IMasterNode, IHasSettings, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
+    class DecalMasterNode : AbstractMaterialNode, IMasterNode, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
     {
         public const string PositionSlotName = "Vertex Position";
         public const string PositionSlotDisplayName = "Vertex Position";
diff --git a/com.unity.render-pipelines.high-definition/Editor/Material/Eye/ShaderGraph/EyeMasterNode.cs b/com.unity.render-pipelines.high-definition/Editor/Material/Eye/ShaderGraph/EyeMasterNode.cs
index a66bb31bfca..ef106ff5316 100644
--- a/com.unity.render-pipelines.high-definition/Editor/Material/Eye/ShaderGraph/EyeMasterNode.cs
+++ b/com.unity.render-pipelines.high-definition/Editor/Material/Eye/ShaderGraph/EyeMasterNode.cs
@@ -19,7 +19,7 @@ namespace UnityEditor.Rendering.HighDefinition
 {
     [Serializable]
     [Title("Master", "Eye (HDRP)(Preview)")]
-    class EyeMasterNode : AbstractMaterialNode, IMasterNode, IHasSettings, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
+    class EyeMasterNode : AbstractMaterialNode, IMasterNode, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
     {
         public const string PositionSlotName = "Vertex Position";
         public const string PositionSlotDisplayName = "Vertex Position";
@@ -229,7 +229,7 @@ public ToggleData alphaTest
                 Dirty(ModificationScope.Topological);
             }
         }
-        
+
         [SerializeField]
         bool m_AlphaToMask = false;
 
diff --git a/com.unity.render-pipelines.high-definition/Editor/Material/Fabric/ShaderGraph/FabricMasterNode.cs b/com.unity.render-pipelines.high-definition/Editor/Material/Fabric/ShaderGraph/FabricMasterNode.cs
index b4fefee9e2d..b531b62a105 100644
--- a/com.unity.render-pipelines.high-definition/Editor/Material/Fabric/ShaderGraph/FabricMasterNode.cs
+++ b/com.unity.render-pipelines.high-definition/Editor/Material/Fabric/ShaderGraph/FabricMasterNode.cs
@@ -21,7 +21,7 @@ namespace UnityEditor.Rendering.HighDefinition
     [Title("Master", "Fabric (HDRP)")]
     [FormerName("UnityEditor.Experimental.Rendering.HDPipeline.FabricMasterNode")]
     [FormerName("UnityEditor.ShaderGraph.FabricMasterNode")]
-    class FabricMasterNode : AbstractMaterialNode, IMasterNode, IHasSettings, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
+    class FabricMasterNode : AbstractMaterialNode, IMasterNode, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
     {
         public const string PositionSlotName = "Vertex Position";
         public const string PositionSlotDisplayName = "Vertex Position";
@@ -234,7 +234,7 @@ public ToggleData alphaTest
                 Dirty(ModificationScope.Topological);
             }
         }
-        
+
         [SerializeField]
         bool m_AlphaToMask = false;
 
diff --git a/com.unity.render-pipelines.high-definition/Editor/Material/Hair/ShaderGraph/HairMasterNode.cs b/com.unity.render-pipelines.high-definition/Editor/Material/Hair/ShaderGraph/HairMasterNode.cs
index 51104346d8e..bf5a688183a 100644
--- a/com.unity.render-pipelines.high-definition/Editor/Material/Hair/ShaderGraph/HairMasterNode.cs
+++ b/com.unity.render-pipelines.high-definition/Editor/Material/Hair/ShaderGraph/HairMasterNode.cs
@@ -20,7 +20,7 @@ namespace UnityEditor.Rendering.HighDefinition
     [Serializable]
     [Title("Master", "Hair (HDRP)")]
     [FormerName("UnityEditor.Experimental.Rendering.HDPipeline.HairMasterNode")]
-    class HairMasterNode : AbstractMaterialNode, IMasterNode, IHasSettings, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
+    class HairMasterNode : AbstractMaterialNode, IMasterNode, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
     {
         public const string PositionSlotName = "Vertex Position";
         public const string PositionSlotDisplayName = "Vertex Position";
@@ -259,7 +259,7 @@ public ToggleData alphaTest
                 Dirty(ModificationScope.Topological);
             }
         }
-        
+
         [SerializeField]
         bool m_AlphaToMask = false;
 
diff --git a/com.unity.render-pipelines.high-definition/Editor/Material/Lit/ShaderGraph/HDLitMasterNode.cs b/com.unity.render-pipelines.high-definition/Editor/Material/Lit/ShaderGraph/HDLitMasterNode.cs
index 101c135ae3d..06f8e6953e1 100644
--- a/com.unity.render-pipelines.high-definition/Editor/Material/Lit/ShaderGraph/HDLitMasterNode.cs
+++ b/com.unity.render-pipelines.high-definition/Editor/Material/Lit/ShaderGraph/HDLitMasterNode.cs
@@ -21,7 +21,7 @@ namespace UnityEditor.Rendering.HighDefinition
     [Title("Master", "Lit (HDRP)")]
     [FormerName("UnityEditor.Experimental.Rendering.HDPipeline.HDLitMasterNode")]
     [FormerName("UnityEditor.ShaderGraph.HDLitMasterNode")]
-    class HDLitMasterNode : AbstractMaterialNode, IMasterNode, IHasSettings, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
+    class HDLitMasterNode : AbstractMaterialNode, IMasterNode, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
     {
         public const string AlbedoSlotName = "Albedo";
         public const string AlbedoDisplaySlotName = "BaseColor";
diff --git a/com.unity.render-pipelines.high-definition/Editor/Material/StackLit/ShaderGraph/StackLitMasterNode.cs b/com.unity.render-pipelines.high-definition/Editor/Material/StackLit/ShaderGraph/StackLitMasterNode.cs
index 3e744888761..fbc644eb20f 100644
--- a/com.unity.render-pipelines.high-definition/Editor/Material/StackLit/ShaderGraph/StackLitMasterNode.cs
+++ b/com.unity.render-pipelines.high-definition/Editor/Material/StackLit/ShaderGraph/StackLitMasterNode.cs
@@ -25,7 +25,7 @@ namespace UnityEditor.Rendering.HighDefinition
     [Title("Master", "StackLit (HDRP)")]
     [FormerName("UnityEditor.Experimental.Rendering.HDPipeline.StackLitMasterNode")]
     [FormerName("UnityEditor.ShaderGraph.StackLitMasterNode")]
-    class StackLitMasterNode : AbstractMaterialNode, IMasterNode, IHasSettings, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
+    class StackLitMasterNode : AbstractMaterialNode, IMasterNode, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
     {
         public const string PositionSlotName = "Vertex Position";
         public const string PositionSlotDisplayName = "Vertex Position";
@@ -360,7 +360,7 @@ public ToggleData alphaTest
                 Dirty(ModificationScope.Topological);
             }
         }
-        
+
         [SerializeField]
         bool m_AlphaToMask = false;
 
diff --git a/com.unity.render-pipelines.high-definition/Editor/Material/Unlit/ShaderGraph/HDUnlitMasterNode.cs b/com.unity.render-pipelines.high-definition/Editor/Material/Unlit/ShaderGraph/HDUnlitMasterNode.cs
index 0da9ede6d50..3a24bb919e7 100644
--- a/com.unity.render-pipelines.high-definition/Editor/Material/Unlit/ShaderGraph/HDUnlitMasterNode.cs
+++ b/com.unity.render-pipelines.high-definition/Editor/Material/Unlit/ShaderGraph/HDUnlitMasterNode.cs
@@ -22,7 +22,7 @@ namespace UnityEditor.Rendering.HighDefinition
     [Serializable]
     [FormerName("UnityEditor.Experimental.Rendering.HDPipeline.HDUnlitMasterNode")]
     [Title("Master", "Unlit (HDRP)")]
-    class HDUnlitMasterNode : AbstractMaterialNode, IMasterNode, IHasSettings, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
+    class HDUnlitMasterNode : AbstractMaterialNode, IMasterNode, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
     {
         public const string ColorSlotName = "Color";
         public const string AlphaSlotName = "Alpha";
diff --git a/com.unity.render-pipelines.universal/Editor/ShaderGraph/MasterNodes/SpriteLitMasterNode.cs b/com.unity.render-pipelines.universal/Editor/ShaderGraph/MasterNodes/SpriteLitMasterNode.cs
index a0a67d8f645..86663e0ce83 100644
--- a/com.unity.render-pipelines.universal/Editor/ShaderGraph/MasterNodes/SpriteLitMasterNode.cs
+++ b/com.unity.render-pipelines.universal/Editor/ShaderGraph/MasterNodes/SpriteLitMasterNode.cs
@@ -12,7 +12,7 @@ namespace UnityEditor.Experimental.Rendering.Universal
     [Serializable]
     [Title("Master", "Sprite Lit (Experimental)")]
     [FormerName("UnityEditor.Experimental.Rendering.LWRP.SpriteLitMasterNode")]
-    class SpriteLitMasterNode : AbstractMaterialNode, IMasterNode, IHasSettings, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
+    class SpriteLitMasterNode : AbstractMaterialNode, IMasterNode, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
     {
         public const string PositionName = "Vertex Position";
         public const string NormalName = "Vertex Normal";
diff --git a/com.unity.render-pipelines.universal/Editor/ShaderGraph/MasterNodes/SpriteUnlitMasterNode.cs b/com.unity.render-pipelines.universal/Editor/ShaderGraph/MasterNodes/SpriteUnlitMasterNode.cs
index 1a6fac62a61..eb2106a0a26 100644
--- a/com.unity.render-pipelines.universal/Editor/ShaderGraph/MasterNodes/SpriteUnlitMasterNode.cs
+++ b/com.unity.render-pipelines.universal/Editor/ShaderGraph/MasterNodes/SpriteUnlitMasterNode.cs
@@ -12,7 +12,7 @@ namespace UnityEditor.Experimental.Rendering.Universal
     [Serializable]
     [Title("Master", "Sprite Unlit (Experimental)")]
     [FormerName("UnityEditor.Experimental.Rendering.LWRP.SpriteUnlitMasterNode")]
-    class SpriteUnlitMasterNode : AbstractMaterialNode, IMasterNode, IHasSettings, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
+    class SpriteUnlitMasterNode : AbstractMaterialNode, IMasterNode, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
     {
         public const string PositionName = "Vertex Position";
         public const string NormalName = "Vertex Normal";
diff --git a/com.unity.shadergraph/Editor/Data/Graphs/GraphData.cs b/com.unity.shadergraph/Editor/Data/Graphs/GraphData.cs
index d78942565de..1466748c660 100644
--- a/com.unity.shadergraph/Editor/Data/Graphs/GraphData.cs
+++ b/com.unity.shadergraph/Editor/Data/Graphs/GraphData.cs
@@ -733,7 +733,7 @@ public List<string> BuildPropertyDisplayNameList(AbstractShaderProperty ignorePr
                     }
                 }
             }
-                    
+
             return result;
         }
 
@@ -901,7 +901,7 @@ void ReplacePropertyNodeWithConcreteNodeNoValidate(PropertyNode propertyNode, bo
 
             var node = property.ToConcreteNode() as AbstractMaterialNode;
             if (node == null)   // Some nodes have no concrete form
-            {                
+            {
                 if (deleteNodeIfNoConcreteFormExists)
                     RemoveNodeNoValidate(propertyNode);
                 return;
diff --git a/com.unity.shadergraph/Editor/Data/Interfaces/IHasSettings.cs b/com.unity.shadergraph/Editor/Data/Interfaces/IHasSettings.cs
deleted file mode 100644
index 257bbb69a12..00000000000
--- a/com.unity.shadergraph/Editor/Data/Interfaces/IHasSettings.cs
+++ /dev/null
@@ -1,9 +0,0 @@
-using UnityEngine.UIElements;
-
-namespace UnityEditor.Graphing
-{
-    interface IHasSettings
-    {
-        VisualElement CreateSettingsElement();
-    }
-}
diff --git a/com.unity.shadergraph/Editor/Data/Interfaces/IHasSettings.cs.meta b/com.unity.shadergraph/Editor/Data/Interfaces/IHasSettings.cs.meta
deleted file mode 100644
index aca0cf41f9d..00000000000
--- a/com.unity.shadergraph/Editor/Data/Interfaces/IHasSettings.cs.meta
+++ /dev/null
@@ -1,11 +0,0 @@
-fileFormatVersion: 2
-guid: aaccc11846e23c84093c0d6780172063
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/com.unity.shadergraph/Editor/Data/Interfaces/IInspectable.cs b/com.unity.shadergraph/Editor/Data/Interfaces/IInspectable.cs
index 950b179fd1a..8b2ae83427f 100644
--- a/com.unity.shadergraph/Editor/Data/Interfaces/IInspectable.cs
+++ b/com.unity.shadergraph/Editor/Data/Interfaces/IInspectable.cs
@@ -1,25 +1,23 @@
-using System;
-using System.Reflection;
-using Data.Interfaces;
-using Drawing.Inspector;
-using UnityEngine.UIElements;
-
-namespace UnityEditor.ShaderGraph.Drawing
-{
-    interface IInspectable
-    {
-        // Implementors can override this in order to display their desired string when selected and viewed through the inscetor
-        string inspectorTitle { get; }
-
-        // This function should return the underlying data object that user wishes to expose to the Inspector
-        object GetObjectToInspect();
-
-        // This function should return the property information of whatever object has been marked up for metadata gathering by the inspector
-        // This might be the same as the object returned by GetObjectToInspect(), it might not
-        PropertyInfo[] GetPropertyInfo();
-
-        // Used to provide any data needed by the property drawer from the inspectable
-        // The inspectorUpdateDelegate is used to trigger an inspector update
-        void SupplyDataToPropertyDrawer(IPropertyDrawer propertyDrawer, Action inspectorUpdateDelegate);
-    }
-}
+using System;
+using System.Reflection;
+using Data.Interfaces;
+using Drawing.Inspector;
+using UnityEngine.UIElements;
+
+namespace UnityEditor.ShaderGraph.Drawing
+{
+    interface IInspectable
+    {
+        // Implementors can override this in order to display their desired string when selected and viewed through the inspector
+        string inspectorTitle { get; }
+
+        // This function should return the underlying data object that user wishes to expose to the Inspector
+        // For simple data properties like Integers/Floats this is the object that contains the properties
+        // For complex types like GraphData this is the GraphData itself, its up to the PropertyDrawer to define what it needs
+        object GetObjectToInspect();
+
+        // Used to provide any data needed by the property drawer from the inspectable
+        // The inspectorUpdateDelegate is used to trigger an inspector update
+        void SupplyDataToPropertyDrawer(IPropertyDrawer propertyDrawer, Action inspectorUpdateDelegate);
+    }
+}
diff --git a/com.unity.shadergraph/Editor/Data/MasterNodes/PBRMasterNode.cs b/com.unity.shadergraph/Editor/Data/MasterNodes/PBRMasterNode.cs
index 75b3922123a..d63d094f429 100644
--- a/com.unity.shadergraph/Editor/Data/MasterNodes/PBRMasterNode.cs
+++ b/com.unity.shadergraph/Editor/Data/MasterNodes/PBRMasterNode.cs
@@ -12,7 +12,7 @@ namespace UnityEditor.ShaderGraph
 {
     [Serializable]
     [Title("Master", "PBR")]
-    class PBRMasterNode : AbstractMaterialNode, IMasterNode, IHasSettings, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
+    class PBRMasterNode : AbstractMaterialNode, IMasterNode, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
     {
         public const string AlbedoSlotName = "Albedo";
         public const string NormalSlotName = "Normal";
diff --git a/com.unity.shadergraph/Editor/Data/MasterNodes/UnlitMasterNode.cs b/com.unity.shadergraph/Editor/Data/MasterNodes/UnlitMasterNode.cs
index edda64926ee..eb5e9f1a54d 100644
--- a/com.unity.shadergraph/Editor/Data/MasterNodes/UnlitMasterNode.cs
+++ b/com.unity.shadergraph/Editor/Data/MasterNodes/UnlitMasterNode.cs
@@ -12,7 +12,7 @@ namespace UnityEditor.ShaderGraph
 {
     [Serializable]
     [Title("Master", "Unlit")]
-    class UnlitMasterNode : AbstractMaterialNode, IMasterNode, IHasSettings, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
+    class UnlitMasterNode : AbstractMaterialNode, IMasterNode, ICanChangeShaderGUI, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent
     {
         public const string ColorSlotName = "Color";
         public const string AlphaSlotName = "Alpha";
diff --git a/com.unity.shadergraph/Editor/Data/MasterNodes/VfxMasterNode.cs b/com.unity.shadergraph/Editor/Data/MasterNodes/VfxMasterNode.cs
index 47d6aeca484..d3d6135c6df 100644
--- a/com.unity.shadergraph/Editor/Data/MasterNodes/VfxMasterNode.cs
+++ b/com.unity.shadergraph/Editor/Data/MasterNodes/VfxMasterNode.cs
@@ -14,7 +14,7 @@ namespace UnityEditor.ShaderGraph
 {
     [Serializable]
     [Title("Master", "Visual Effect")]
-    sealed class VfxMasterNode : AbstractMaterialNode, IMasterNode, IHasSettings, IMayRequirePosition
+    sealed class VfxMasterNode : AbstractMaterialNode, IMasterNode, IMayRequirePosition
     {
         const string BaseColorSlotName = "Base Color";
         const string MetallicSlotName = "Metallic";
diff --git a/com.unity.shadergraph/Editor/Data/Nodes/AbstractMaterialNode.cs b/com.unity.shadergraph/Editor/Data/Nodes/AbstractMaterialNode.cs
index 92d56ecce98..94b7433e796 100644
--- a/com.unity.shadergraph/Editor/Data/Nodes/AbstractMaterialNode.cs
+++ b/com.unity.shadergraph/Editor/Data/Nodes/AbstractMaterialNode.cs
@@ -92,7 +92,6 @@ public virtual bool canSetPrecision
 
         private ConcretePrecision m_ConcretePrecision = ConcretePrecision.Float;
 
-        [Inspectable("Precision", ConcretePrecision.Float)]
         public ConcretePrecision concretePrecision
         {
             get => m_ConcretePrecision;
diff --git a/com.unity.shadergraph/Editor/Data/Nodes/Input/Texture/SampleVirtualTextureNode.cs b/com.unity.shadergraph/Editor/Data/Nodes/Input/Texture/SampleVirtualTextureNode.cs
index 8c5512d9b9e..14af83afa88 100644
--- a/com.unity.shadergraph/Editor/Data/Nodes/Input/Texture/SampleVirtualTextureNode.cs
+++ b/com.unity.shadergraph/Editor/Data/Nodes/Input/Texture/SampleVirtualTextureNode.cs
@@ -14,7 +14,7 @@
 namespace UnityEditor.ShaderGraph
 {
     [Title("Input", "Texture", SampleVirtualTextureNode.DefaultNodeTitle)]
-    class SampleVirtualTextureNode : AbstractMaterialNode, IGeneratesBodyCode, IGeneratesFunction, IMayRequireMeshUV, IMayRequireTime, IMayRequireScreenPosition, IHasSettings
+    class SampleVirtualTextureNode : AbstractMaterialNode, IGeneratesBodyCode, IGeneratesFunction, IMayRequireMeshUV, IMayRequireTime, IMayRequireScreenPosition
     {
         public const string DefaultNodeTitle = "Sample Virtual Texture";
 
@@ -144,6 +144,8 @@ public bool noFeedback
             }
         }
 
+        public TextureType[] textureTypes => m_TextureTypes;
+
         [SerializeField]
         protected TextureType[] m_TextureTypes = { TextureType.Default, TextureType.Default, TextureType.Default, TextureType.Default };
 
@@ -164,143 +166,6 @@ public NormalMapSpace normalMapSpace
             }
         }
 
-        /*
-            The panel behind the cogwheel node settings
-        */
-        class SampleVirtualTextureNodeSettingsView : VisualElement
-        {
-            SampleVirtualTextureNode m_Node;
-            public SampleVirtualTextureNodeSettingsView(SampleVirtualTextureNode node)
-            {
-                m_Node = node;
-
-                PropertySheet ps = new PropertySheet();
-
-                ps.Add(new PropertyRow(new Label("Lod Mode")), (row) =>
-                {
-                    row.Add(new UIElements.EnumField(m_Node.lodCalculation), (field) =>
-                    {
-                        field.value = m_Node.lodCalculation;
-                        field.RegisterValueChangedCallback(evt =>
-                        {
-                            if (m_Node.lodCalculation == (LodCalculation)evt.newValue)
-                                return;
-
-                            m_Node.owner.owner.RegisterCompleteObjectUndo("Lod Mode Change");
-                            m_Node.lodCalculation = (LodCalculation)evt.newValue;
-                        });
-                    });
-                });
-
-                ps.Add(new PropertyRow(new Label("Quality")), (row) =>
-                {
-                    row.Add(new UIElements.EnumField(m_Node.sampleQuality), (field) =>
-                    {
-                        field.value = m_Node.sampleQuality;
-                        field.RegisterValueChangedCallback(evt =>
-                        {
-                            if (m_Node.sampleQuality == (QualityMode)evt.newValue)
-                                return;
-
-                            m_Node.owner.owner.RegisterCompleteObjectUndo("Quality Change");
-                            m_Node.sampleQuality = (QualityMode)evt.newValue;
-                        });
-                    });
-                });
-
-                ps.Add(new PropertyRow(new Label("No Feedback")), (row) =>
-                {
-                    row.Add(new UnityEngine.UIElements.Toggle(), (field) =>
-                    {
-                        field.value = m_Node.noFeedback;
-                        field.RegisterValueChangedCallback(evt =>
-                        {
-                            if (m_Node.noFeedback == evt.newValue)
-                                return;
-
-                            m_Node.owner.owner.RegisterCompleteObjectUndo("Feedback Settings Change");
-                            m_Node.noFeedback = evt.newValue;
-                        });
-                    });
-                });
-
-                var vtProperty = m_Node.GetSlotProperty(VirtualTextureInputId) as VirtualTextureShaderProperty;
-                if (vtProperty == null)
-                {
-                    ps.Add(new HelpBoxRow(MessageType.Warning), (row) => row.Add(new Label("Please connect a VirtualTexture property to configure texture sampling type.")));
-                }
-                else
-                {
-                    int numLayers = vtProperty.value.layers.Count;
-
-                    for (int i = 0; i < numLayers; i++)
-                    {
-                        int currentIndex = i;   // to make lambda by-ref capturing happy
-                        ps.Add(new PropertyRow(new Label("Layer " + (i + 1) + " Type")), (row) =>
-                        {
-                            row.Add(new UIElements.EnumField(m_Node.m_TextureTypes[i]), (field) =>
-                            {
-                                field.value = m_Node.m_TextureTypes[i];
-                                field.RegisterValueChangedCallback(evt =>
-                                {
-                                    if (m_Node.m_TextureTypes[currentIndex] == (TextureType)evt.newValue)
-                                        return;
-
-                                    m_Node.owner.owner.RegisterCompleteObjectUndo("Texture Type Change");
-                                    m_Node.m_TextureTypes[currentIndex] = (TextureType)evt.newValue;
-                                    m_Node.Dirty(ModificationScope.Graph);
-                                });
-                            });
-                        });
-                    }
-                }
-
-                ps.Add(new PropertyRow(new Label("Normal Space")), (row) =>
-                {
-                    row.Add(new UIElements.EnumField(m_Node.normalMapSpace), (field) =>
-                    {
-                        field.value = m_Node.normalMapSpace;
-                        field.RegisterValueChangedCallback(evt =>
-                        {
-                            if (m_Node.normalMapSpace == (NormalMapSpace)evt.newValue)
-                                return;
-
-                            m_Node.owner.owner.RegisterCompleteObjectUndo("Normal Map space Change");
-                            m_Node.normalMapSpace = (NormalMapSpace)evt.newValue;
-                        });
-                    });
-                });
-
-                // display warning if the current master node doesn't support virtual texturing
-                if (!m_Node.owner.isSubGraph)
-                {
-                    bool supportedByMasterNode = m_Node.owner.GetNodes<IMasterNode>().FirstOrDefault()?.supportsVirtualTexturing ?? false;
-                    if (!supportedByMasterNode)
-                        ps.Add(new HelpBoxRow(MessageType.Warning), (row) => row.Add(new Label("The current master node does not support Virtual Texturing, this node will do regular 2D sampling.")));
-                }
-
-                // display warning if the current render pipeline doesn't support virtual texturing
-                IVirtualTexturingEnabledRenderPipeline vtRp = GraphicsSettings.currentRenderPipeline as IVirtualTexturingEnabledRenderPipeline;
-                if (vtRp == null)
-                    ps.Add(new HelpBoxRow(MessageType.Warning), (row) => row.Add(new Label("The current render pipeline does not support Virtual Texturing, this node will do regular 2D sampling.")));
-                else if (vtRp.virtualTexturingEnabled == false)
-                    ps.Add(new HelpBoxRow(MessageType.Warning), (row) => row.Add(new Label("The current render pipeline has disabled Virtual Texturing, this node will do regular 2D sampling.")));
-                else
-                {
-#if !ENABLE_VIRTUALTEXTURES
-                    ps.Add(new HelpBoxRow(MessageType.Warning), (row) => row.Add(new Label("Virtual Texturing is disabled globally (possibly by the render pipeline settings), this node will do regular 2D sampling.")));
-#endif
-                }
-
-                Add(ps);
-            }
-        }
-
-        public VisualElement CreateSettingsElement()
-        {
-            return new SampleVirtualTextureNodeSettingsView(this);
-        }
-
         public SampleVirtualTextureNode() : this(false, false)
         { }
 
diff --git a/com.unity.shadergraph/Editor/Data/Nodes/Utility/CustomFunctionNode.cs b/com.unity.shadergraph/Editor/Data/Nodes/Utility/CustomFunctionNode.cs
index da018bf7446..c027479c2a3 100644
--- a/com.unity.shadergraph/Editor/Data/Nodes/Utility/CustomFunctionNode.cs
+++ b/com.unity.shadergraph/Editor/Data/Nodes/Utility/CustomFunctionNode.cs
@@ -12,7 +12,7 @@ namespace UnityEditor.ShaderGraph
 {
     [HasDependencies(typeof(MinimalCustomFunctionNode))]
     [Title("Utility", "Custom Function")]
-    class CustomFunctionNode : AbstractMaterialNode, IGeneratesBodyCode, IGeneratesFunction, IHasSettings
+    class CustomFunctionNode : AbstractMaterialNode, IGeneratesBodyCode, IGeneratesFunction
     {
         [Serializable]
         public class MinimalCustomFunctionNode : IHasDependencies
@@ -317,15 +317,6 @@ public void Reload(HashSet<string> changedFileDependencies)
             }
         }
 
-        public VisualElement CreateSettingsElement()
-        {
-            PropertySheet ps = new PropertySheet();
-            ps.Add(new ReorderableSlotListView(this, SlotType.Input));
-            ps.Add(new ReorderableSlotListView(this, SlotType.Output));
-            ps.Add(new HlslFunctionView(this));
-            return ps;
-        }
-
         public static string UpgradeFunctionSource(string functionSource)
         {
             // Handle upgrade from legacy asset path version
diff --git a/com.unity.shadergraph/Editor/Data/SubGraph/SubGraphOutputNode.cs b/com.unity.shadergraph/Editor/Data/SubGraph/SubGraphOutputNode.cs
index b01bbed1d98..3ecaf0fa98b 100644
--- a/com.unity.shadergraph/Editor/Data/SubGraph/SubGraphOutputNode.cs
+++ b/com.unity.shadergraph/Editor/Data/SubGraph/SubGraphOutputNode.cs
@@ -11,7 +11,7 @@
 
 namespace UnityEditor.ShaderGraph
 {
-    class SubGraphOutputNode : AbstractMaterialNode, IHasSettings
+    class SubGraphOutputNode : AbstractMaterialNode
     {
         static string s_MissingOutputSlot = "A Sub Graph must have at least one output slot";
         static List<ConcreteSlotValueType> s_ValidSlotTypes = new List<ConcreteSlotValueType>()
@@ -114,13 +114,6 @@ public int AddSlot(ConcreteSlotValueType concreteValueType)
             return index;
         }
 
-        public VisualElement CreateSettingsElement()
-        {
-            PropertySheet ps = new PropertySheet();
-            ps.Add(new ReorderableSlotListView(this, SlotType.Input));
-            return ps;
-        }
-
         public override bool canDeleteNode => false;
 
         public override bool canCopyNode => false;
diff --git a/com.unity.shadergraph/Editor/Drawing/Blackboard/BlackboardFieldView.cs b/com.unity.shadergraph/Editor/Drawing/Blackboard/BlackboardFieldView.cs
index c65cfc9147e..c52eff99d63 100644
--- a/com.unity.shadergraph/Editor/Drawing/Blackboard/BlackboardFieldView.cs
+++ b/com.unity.shadergraph/Editor/Drawing/Blackboard/BlackboardFieldView.cs
@@ -66,7 +66,7 @@ private void DirtyNodes(ModificationScope modificationScope = ModificationScope.
         }
 
         // When the properties are changed, this delegate is used to trigger an update in the view that represents those properties
-        private Action m_propertyViewUpdateTrigger;
+        private Action m_inspectorUpdateTrigger;
         private ShaderInputPropertyDrawer.ChangeReferenceNameCallback m_resetReferenceNameTrigger;
 
         public string inspectorTitle
@@ -137,14 +137,11 @@ public void SupplyDataToPropertyDrawer(IPropertyDrawer propertyDrawer, Action in
                     RegisterPropertyChangeUndo,
                     MarkNodesAsDirty);
 
-                m_propertyViewUpdateTrigger = inspectorUpdateDelegate;
+                m_inspectorUpdateTrigger = inspectorUpdateDelegate;
                 m_resetReferenceNameTrigger = shaderInputPropertyDrawer._resetReferenceNameCallback;
-            }
-        }
 
-        public PropertyInfo[] GetPropertyInfo()
-        {
-            return GetType().GetProperties();
+                this.RegisterCallback<DetachFromPanelEvent>(evt => m_inspectorUpdateTrigger());
+            }
         }
 
         void ChangeExposedField(bool newValue)
@@ -170,7 +167,7 @@ void MarkNodesAsDirty(bool triggerPropertyViewUpdate = false, ModificationScope
         {
             DirtyNodes(modificationScope);
             if(triggerPropertyViewUpdate)
-                m_propertyViewUpdateTrigger();
+                m_inspectorUpdateTrigger();
         }
 
         void ChangePropertyValue(object newValue)
diff --git a/com.unity.shadergraph/Editor/Drawing/Blackboard/BlackboardProvider.cs b/com.unity.shadergraph/Editor/Drawing/Blackboard/BlackboardProvider.cs
index ac8fcaba640..819566b47a1 100644
--- a/com.unity.shadergraph/Editor/Drawing/Blackboard/BlackboardProvider.cs
+++ b/com.unity.shadergraph/Editor/Drawing/Blackboard/BlackboardProvider.cs
@@ -19,6 +19,7 @@ class BlackboardProvider
 
         public const int k_PropertySectionIndex = 0;
         public const int k_KeywordSectionIndex = 1;
+        const string k_styleName = "Blackboard";
 
         public Blackboard blackboard { get; private set; }
         Label m_PathLabel;
@@ -49,6 +50,9 @@ public BlackboardProvider(GraphData graph)
                 moveItemRequested = MoveItemRequested
             };
 
+            var styleSheet = Resources.Load<StyleSheet>($"Styles/{k_styleName}");
+            blackboard.styleSheets.Add(styleSheet);
+
             m_PathLabel = blackboard.hierarchy.ElementAt(0).Q<Label>("subTitleLabel");
             m_PathLabel.RegisterCallback<MouseDownEvent>(OnMouseDownEvent);
 
diff --git a/com.unity.shadergraph/Editor/Drawing/Inspector/InspectorView.cs b/com.unity.shadergraph/Editor/Drawing/Inspector/InspectorView.cs
index 2c77a0e7a14..afa63a98c2e 100644
--- a/com.unity.shadergraph/Editor/Drawing/Inspector/InspectorView.cs
+++ b/com.unity.shadergraph/Editor/Drawing/Inspector/InspectorView.cs
@@ -1,76 +1,104 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
- using Data.Interfaces;
- using UnityEditor.Experimental.GraphView;
- using UnityEditor.ShaderGraph.Drawing.Inspector.PropertyDrawers;
- using UnityEditor.ShaderGraph.Drawing.Views;
- using UnityEngine;
- using UnityEngine.UIElements;
-
- namespace UnityEditor.ShaderGraph.Drawing.Inspector
- {
+using Data.Interfaces;
+using UnityEditor.Experimental.GraphView;
+using UnityEditor.ShaderGraph.Drawing.Inspector.PropertyDrawers;
+using UnityEditor.ShaderGraph.Drawing.Views;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace UnityEditor.ShaderGraph.Drawing.Inspector
+{
     class InspectorView : GraphSubWindow
     {
-        // References
         readonly List<Type> m_PropertyDrawerList = new List<Type>();
 
+        List<ISelectable> m_CachedSelectionList = new List<ISelectable>();
+        bool isShowingGraphSettings { get; set; }
+
         // There's persistent data that is stored in the graph settings property drawer that we need to hold onto between interactions
         IPropertyDrawer m_graphSettingsPropertyDrawer = new GraphDataPropertyDrawer();
-        Action m_previewUpdateDelegate;
         protected override string windowTitle => "Inspector";
         protected override string elementName => "InspectorView";
         protected override string styleName => "InspectorView";
 
-        void RegisterPropertyDrawer(Type propertyDrawerType)
+        void RegisterPropertyDrawer(Type newPropertyDrawerType)
         {
-            if(typeof(IPropertyDrawer).IsAssignableFrom(propertyDrawerType) == false)
+            if (typeof(IPropertyDrawer).IsAssignableFrom(newPropertyDrawerType) == false)
                 Debug.Log("Attempted to register a property drawer that doesn't inherit from IPropertyDrawer!");
 
-            var customAttribute = propertyDrawerType.GetCustomAttribute<SGPropertyDrawerAttribute>();
-            if(customAttribute != null)
-                m_PropertyDrawerList.Add(propertyDrawerType);
+            var newPropertyDrawerAttribute = newPropertyDrawerType.GetCustomAttribute<SGPropertyDrawerAttribute>();
+
+            if (newPropertyDrawerAttribute != null)
+            {
+                foreach (var existingPropertyDrawerType in m_PropertyDrawerList)
+                {
+                    var existingPropertyDrawerAttribute = existingPropertyDrawerType.GetCustomAttribute<SGPropertyDrawerAttribute>();
+                    if (newPropertyDrawerAttribute.propertyType.IsSubclassOf(existingPropertyDrawerAttribute.propertyType))
+                    {
+                        // Derived types need to be at start of list
+                        m_PropertyDrawerList.Insert(0, newPropertyDrawerType);
+                        return;
+                    }
+
+                    if (existingPropertyDrawerAttribute.propertyType.IsSubclassOf(newPropertyDrawerAttribute.propertyType))
+                    {
+                        // Add new base class type to end of list
+                        m_PropertyDrawerList.Add(newPropertyDrawerType);
+                        // Shift already added existing type to the beginning of the list
+                        m_PropertyDrawerList.Remove(existingPropertyDrawerType);
+                        m_PropertyDrawerList.Insert(0, existingPropertyDrawerType);
+                        return;
+                    }
+                }
+
+                m_PropertyDrawerList.Add(newPropertyDrawerType);
+            }
             else
-                Debug.Log("Attempted to register a property drawer that isn't marked up with the SGPropertyDrawer attribute!");
+                Debug.Log("Attempted to register property drawer: " + newPropertyDrawerType + " that isn't marked up with the SGPropertyDrawer attribute!");
         }
 
-        public InspectorView(GraphView graphView, Action updatePreviewDelegate) : base(graphView)
+        public InspectorView(GraphView graphView) : base(graphView)
         {
-            m_previewUpdateDelegate = updatePreviewDelegate;
-
             var unregisteredPropertyDrawerTypes = TypeCache.GetTypesDerivedFrom<IPropertyDrawer>().ToList();
 
             foreach (var type in unregisteredPropertyDrawerTypes)
             {
                 RegisterPropertyDrawer(type);
             }
+
+            // By default at startup, the inspector should be hidden
+            this.style.visibility = Visibility.Hidden;
+        }
+
+
+        // If any of the selected items are no longer selected, inspector requires an update
+        public bool DoesInspectorNeedUpdate()
+        {
+            var needUpdate = !m_CachedSelectionList.SequenceEqual(selection);
+            if(needUpdate)
+                isShowingGraphSettings = false;
+            return needUpdate;
         }
 
-#region Selection
         public void Update()
         {
             m_ContentContainer.Clear();
 
-            if(selection.Count == 0)
-            {
-                ShowGraphSettings(m_ContentContainer);
-            }
-            else if(selection.Count == 1)
+            if(isShowingGraphSettings)
             {
-                var inspectable = selection.First() as IInspectable;
-                subTitle = $"{inspectable?.inspectorTitle}.";
-            }
-            else if(selection.Count > 1)
-            {
-                subTitle = $"{selection.Count} Objects.";
+                ShowGraphSettings();
+                return;
             }
 
             try
             {
                 foreach (var selectable in selection)
                 {
-                    DrawSelection(selectable, m_ContentContainer);
+                    if(selectable is IInspectable inspectable)
+                        DrawInspectable(m_ContentContainer, inspectable);
                 }
             }
             catch (Exception e)
@@ -79,15 +107,31 @@ public void Update()
                 throw;
             }
 
-            m_ContentContainer.MarkDirtyRepaint();
-        }
+            // Store this for update checks later, copying list deliberately as we dont want a reference
+            m_CachedSelectionList = new List<ISelectable>(selection);
 
-        void DrawSelection(ISelectable selectable, VisualElement outputVisualElement)
-        {
-            if(selectable is IInspectable inspectable)
+            // Things can be selected that don't have an inspector representation,
+            // this check makes sure the inspector window doesn't show if there weren't any things to actually inspect
+            if (m_ContentContainer.childCount != 0)
+            {
+                ShowWindow();
+            }
+            else
             {
-                DrawInspectable(outputVisualElement, inspectable);
+                HideWindow();
             }
+
+            if (selection.Count == 1)
+            {
+                var inspectable = selection.First() as IInspectable;
+                subTitle = $"{inspectable?.inspectorTitle}.";
+            }
+            else if (selection.Count > 1)
+            {
+                subTitle = $"{selection.Count} Objects.";
+            }
+
+            m_ContentContainer.MarkDirtyRepaint();
         }
 
         void DrawInspectable(
@@ -95,18 +139,24 @@ void DrawInspectable(
             IInspectable inspectable,
             IPropertyDrawer propertyDrawerToUse = null)
         {
-            InspectorUtils.GatherInspectorContent(m_PropertyDrawerList, outputVisualElement, inspectable, TriggerInspectorAndPreviewUpdate, propertyDrawerToUse);
+            InspectorUtils.GatherInspectorContent(m_PropertyDrawerList, outputVisualElement, inspectable, TriggerInspectorUpdate, propertyDrawerToUse);
         }
 
-        void TriggerInspectorAndPreviewUpdate()
+        void TriggerInspectorUpdate()
         {
-            m_previewUpdateDelegate();
             Update();
         }
 
+        public void ShowGraphSettings()
+        {
+            isShowingGraphSettings = true;
+            ShowWindow();
+            ShowGraphSettings_Internal(m_ContentContainer);
+        }
+
         // This should be implemented by any inspector class that wants to define its own GraphSettings
         // which for SG, is a representation of the settings in GraphData
-        protected virtual void ShowGraphSettings(VisualElement contentContainer)
+        protected virtual void ShowGraphSettings_Internal(VisualElement contentContainer)
         {
             var graphEditorView = m_GraphView.GetFirstAncestorOfType<GraphEditorView>();
             if(graphEditorView == null)
@@ -114,12 +164,12 @@ protected virtual void ShowGraphSettings(VisualElement contentContainer)
 
             subTitle = $"{graphEditorView.assetName} (Graph)";
 
+            contentContainer.Clear();
             DrawInspectable(contentContainer, (IInspectable)graphView, m_graphSettingsPropertyDrawer);
+            contentContainer.MarkDirtyRepaint();
         }
-#endregion
     }
 
-
     public static class InspectorUtils
     {
         internal static void GatherInspectorContent(
@@ -133,7 +183,7 @@ internal static void GatherInspectorContent(
             if (dataObject == null)
                 throw new NullReferenceException("DataObject returned by Inspectable is null!");
 
-            var properties = inspectable.GetPropertyInfo();
+            var properties = inspectable.GetType().GetProperties(BindingFlags.Default | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
             if (properties == null)
                 throw new NullReferenceException("PropertyInfos returned by Inspectable is null!");
 
@@ -143,7 +193,7 @@ internal static void GatherInspectorContent(
                 if (attribute == null)
                     continue;
 
-                var propertyType = propertyInfo.PropertyType;
+                var propertyType = propertyInfo.GetGetMethod(true).Invoke(inspectable, new object[] {}).GetType();
 
                 if (IsPropertyTypeHandled(propertyDrawerList, propertyType, out var propertyDrawerTypeToUse))
                 {
@@ -159,7 +209,9 @@ internal static void GatherInspectorContent(
             }
         }
 
-        static bool IsPropertyTypeHandled(List<Type> propertyDrawerList, Type typeOfProperty,
+        static bool IsPropertyTypeHandled(
+            List<Type> propertyDrawerList,
+            Type typeOfProperty,
             out Type propertyDrawerToUse)
         {
             propertyDrawerToUse = null;
@@ -177,6 +229,7 @@ static bool IsPropertyTypeHandled(List<Type> propertyDrawerList, Type typeOfProp
                 // Generics and Enumerable types are handled here
                 else if (typeHandledByPropertyDrawer.propertyType.IsAssignableFrom(typeOfProperty))
                 {
+                    // Before returning it, check for a more appropriate type further
                     propertyDrawerToUse = propertyDrawerType;
                     return true;
                 }
@@ -187,7 +240,6 @@ static bool IsPropertyTypeHandled(List<Type> propertyDrawerList, Type typeOfProp
                     return true;
                 }
             }
-
             return false;
         }
     }
diff --git a/com.unity.shadergraph/Editor/Drawing/Inspector/MasterPreviewView.cs b/com.unity.shadergraph/Editor/Drawing/Inspector/MasterPreviewView.cs
index 493aca918fd..57ba04b5297 100644
--- a/com.unity.shadergraph/Editor/Drawing/Inspector/MasterPreviewView.cs
+++ b/com.unity.shadergraph/Editor/Drawing/Inspector/MasterPreviewView.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.Eventing.Reader;
 using System.Linq;
 using System.Reflection;
 using UnityEngine;
@@ -107,13 +108,13 @@ public MasterPreviewView(PreviewManager previewManager, GraphData graph)
             }
             Add(preview);
 
-            m_PreviewResizeBorderFrame = new ResizeBorderFrame(previewTextureView, this) { name = "resizeBorderFrame" };
+            m_PreviewResizeBorderFrame = new ResizeBorderFrame(this, this) { name = "resizeBorderFrame" };
             m_PreviewResizeBorderFrame.maintainAspectRatio = true;
             Add(m_PreviewResizeBorderFrame);
 
             m_ExpandedPreviewSize = new Vector2(256f, 256f);
             m_RecalculateLayout = false;
-            previewTextureView.RegisterCallback<GeometryChangedEvent>(OnGeometryChanged);
+            this.RegisterCallback<GeometryChangedEvent>(OnGeometryChanged);
         }
 
         Image CreatePreview(Texture texture)
@@ -222,7 +223,9 @@ void OnGeometryChanged(GeometryChangedEvent evt)
             if (Mathf.Approximately(currentWidth, targetHeight) && Mathf.Approximately(currentHeight, targetWidth))
                 return;
 
-            m_PreviewManager.ResizeMasterPreview(new Vector2(targetWidth, targetHeight));
+            m_PreviewTextureView.style.width = evt.newRect.width;
+            m_PreviewTextureView.style.height = evt.newRect.height - 40.0f;
+            m_PreviewManager.ResizeMasterPreview(new Vector2(evt.newRect.width, evt.newRect.width));
         }
 
         void OnScroll(float scrollValue)
diff --git a/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/AbstractMaterialNodePropertyDrawer.cs b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/AbstractMaterialNodePropertyDrawer.cs
new file mode 100644
index 00000000000..5a612a30600
--- /dev/null
+++ b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/AbstractMaterialNodePropertyDrawer.cs
@@ -0,0 +1,68 @@
+using System;
+using System.Reflection;
+using Data.Interfaces;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph;
+using UnityEditor.ShaderGraph.Drawing;
+using UnityEditor.ShaderGraph.Drawing.Inspector;
+using UnityEditor.ShaderGraph.Internal;
+using UnityEngine.UIElements;
+using UnityEditor.UIElements;
+using UnityEditor.Graphing.Util;
+using UnityEngine;
+
+namespace Drawing.Inspector.PropertyDrawers
+{
+    [SGPropertyDrawer(typeof(AbstractMaterialNode))]
+    public class AbstractMaterialNodePropertyDrawer : IPropertyDrawer
+    {
+        public Action inspectorUpdateDelegate { get; set; }
+
+        Action m_setNodesAsDirtyCallback;
+        Action m_updateNodeViewsCallback;
+
+        public void GetPropertyData(Action setNodesAsDirtyCallback, Action updateNodeViewsCallback)
+        {
+            m_setNodesAsDirtyCallback = setNodesAsDirtyCallback;
+            m_updateNodeViewsCallback = updateNodeViewsCallback;
+        }
+
+        VisualElement CreateGUI(AbstractMaterialNode node, InspectableAttribute attribute, out VisualElement propertyVisualElement)
+        {
+            VisualElement defaultRow = null;
+            EnumField precisionField = null;
+            if(node.canSetPrecision)
+            {
+                precisionField = new EnumField(node.precision);
+                defaultRow = new PropertyRow(new Label("Precision"));
+                defaultRow.Add(precisionField, (field) =>
+                {
+                    field.RegisterValueChangedCallback(evt =>
+                    {
+                        if (evt.newValue.Equals(node.precision))
+                            return;
+
+                        m_setNodesAsDirtyCallback();
+                        node.owner.owner.RegisterCompleteObjectUndo("Change precision");
+                        node.precision = (Precision)evt.newValue;
+                        node.owner.ValidateGraph();
+                        m_updateNodeViewsCallback();
+                        node.Dirty(ModificationScope.Graph);
+                    });
+                });
+
+                defaultRow.Add(precisionField);
+                defaultRow.styleSheets.Add(Resources.Load<StyleSheet>("Styles/PropertyRow"));
+            }
+            propertyVisualElement = precisionField;
+            return defaultRow;
+        }
+        public VisualElement DrawProperty(PropertyInfo propertyInfo, object actualObject, InspectableAttribute attribute)
+        {
+            return this.CreateGUI(
+                (AbstractMaterialNode) actualObject,
+                attribute,
+                out var propertyVisualElement);
+        }
+    }
+}
diff --git a/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/AbstractMaterialNodePropertyDrawer.cs.meta b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/AbstractMaterialNodePropertyDrawer.cs.meta
new file mode 100644
index 00000000000..9241c1d0c30
--- /dev/null
+++ b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/AbstractMaterialNodePropertyDrawer.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6436de6b57634b32a3c95d37c1b9b2c0
+timeCreated: 1588712275
\ No newline at end of file
diff --git a/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/CustomFunctionNodePropertyDrawer.cs b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/CustomFunctionNodePropertyDrawer.cs
new file mode 100644
index 00000000000..2fe56943f0d
--- /dev/null
+++ b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/CustomFunctionNodePropertyDrawer.cs
@@ -0,0 +1,45 @@
+using System;
+using System.Reflection;
+using Data.Interfaces;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph;
+using UnityEditor.ShaderGraph.Drawing;
+using UnityEditor.ShaderGraph.Drawing.Inspector;
+using UnityEngine.UIElements;
+
+namespace Drawing.Inspector.PropertyDrawers
+{
+    [SGPropertyDrawer(typeof(CustomFunctionNode))]
+    public class CustomFunctionNodePropertyDrawer : IPropertyDrawer
+    {
+        VisualElement CreateGUI(CustomFunctionNode node, InspectableAttribute attribute,
+            out VisualElement propertyVisualElement)
+        {
+            var propertySheet = new PropertySheet(PropertyDrawerUtils.CreateLabel(attribute.labelName));
+            var inputListView = new ReorderableSlotListView(node, SlotType.Input);
+            inputListView.OnAddCallback += list => inspectorUpdateDelegate();
+            inputListView.OnRemoveCallback += list => inspectorUpdateDelegate();
+            inputListView.OnListRecreatedCallback += () => inspectorUpdateDelegate();
+            propertySheet.Add(inputListView);
+            var outputListView = new ReorderableSlotListView(node, SlotType.Output);
+            outputListView.OnAddCallback += list => inspectorUpdateDelegate();
+            outputListView.OnRemoveCallback += list => inspectorUpdateDelegate();
+            outputListView.OnListRecreatedCallback += () => inspectorUpdateDelegate();
+            propertySheet.Add(outputListView);
+            propertySheet.Add(new HlslFunctionView(node));
+            propertyVisualElement = propertySheet;
+            return propertySheet;
+        }
+
+        public Action inspectorUpdateDelegate { get; set; }
+
+        public VisualElement DrawProperty(PropertyInfo propertyInfo, object actualObject,
+            InspectableAttribute attribute)
+        {
+            return this.CreateGUI(
+                (CustomFunctionNode) actualObject,
+                attribute,
+                out var propertyVisualElement);
+        }
+    }
+}
diff --git a/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/CustomFunctionNodePropertyDrawer.cs.meta b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/CustomFunctionNodePropertyDrawer.cs.meta
new file mode 100644
index 00000000000..86939d91f16
--- /dev/null
+++ b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/CustomFunctionNodePropertyDrawer.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5b314925e5a04562b330a7147571e838
+timeCreated: 1588810391
\ No newline at end of file
diff --git a/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/GraphDataPropertyDrawer.cs b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/GraphDataPropertyDrawer.cs
index f4cd6524888..e73d1651dcb 100644
--- a/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/GraphDataPropertyDrawer.cs
+++ b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/GraphDataPropertyDrawer.cs
@@ -1,8 +1,10 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Reflection;
 using Data.Interfaces;
-using UnityEditor.ShaderGraph;
-using UnityEditor.ShaderGraph.Drawing;
+using Drawing.Views;
+using UnityEditor.Graphing.Util;
 using UnityEditor.ShaderGraph.Internal;
 using UnityEngine;
 using UnityEngine.UIElements;
@@ -13,16 +15,11 @@ namespace UnityEditor.ShaderGraph.Drawing.Inspector.PropertyDrawers
     public class GraphDataPropertyDrawer : IPropertyDrawer
     {
         public delegate void ChangeConcretePrecisionCallback(ConcretePrecision newValue);
-        public delegate void PostTargetSettingsChangedCallback();
 
-        PostTargetSettingsChangedCallback m_postChangeTargetSettingsCallback;
         ChangeConcretePrecisionCallback m_postChangeConcretePrecisionCallback;
 
-        public void GetPropertyData(
-            PostTargetSettingsChangedCallback postChangeValueCallback,
-            ChangeConcretePrecisionCallback changeConcretePrecisionCallback)
+        public void GetPropertyData(ChangeConcretePrecisionCallback changeConcretePrecisionCallback)
         {
-            m_postChangeTargetSettingsCallback = postChangeValueCallback;
             m_postChangeConcretePrecisionCallback = changeConcretePrecisionCallback;
         }
 
diff --git a/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/IntegerPropertyDrawer.cs b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/IntegerPropertyDrawer.cs
index ad49062e26a..1dd67d935e4 100644
--- a/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/IntegerPropertyDrawer.cs
+++ b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/IntegerPropertyDrawer.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Reflection;
 using Data.Interfaces;
-using UnityEditor.ShaderGraph.Drawing;
 using UnityEditor.UIElements;
 using UnityEngine;
 using UnityEngine.UIElements;
diff --git a/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/SampleVirtualTextureNodePropertyDrawer.cs b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/SampleVirtualTextureNodePropertyDrawer.cs
new file mode 100644
index 00000000000..be360573396
--- /dev/null
+++ b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/SampleVirtualTextureNodePropertyDrawer.cs
@@ -0,0 +1,156 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using Data.Interfaces;
+using UnityEditor;
+using UnityEditor.Graphing;
+using UnityEditor.Graphing.Util;
+using UnityEditor.ShaderGraph;
+using UnityEditor.ShaderGraph.Drawing;
+using UnityEditor.ShaderGraph.Drawing.Inspector.PropertyDrawers;
+using UnityEditor.UIElements;
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.UIElements;
+
+namespace Drawing.Inspector.PropertyDrawers
+{
+    [SGPropertyDrawer(typeof(SampleVirtualTextureNode))]
+    public class SampleVirtualTextureNodePropertyDrawer : IPropertyDrawer
+    {
+        VisualElement CreateGUI(SampleVirtualTextureNode node, InspectableAttribute attribute,
+            out VisualElement propertyVisualElement)
+        {
+            PropertySheet propertySheet = new PropertySheet();
+
+            var enumPropertyDrawer = new EnumPropertyDrawer();
+            propertySheet.Add(enumPropertyDrawer.CreateGUI((newValue) =>
+                {
+                    if (node.lodCalculation == (SampleVirtualTextureNode.LodCalculation) newValue)
+                        return;
+
+                    node.owner.owner.RegisterCompleteObjectUndo("Lod Mode Change");
+                    node.lodCalculation = (SampleVirtualTextureNode.LodCalculation) newValue;
+                },
+                node.lodCalculation,
+                "Lod Mode",
+                SampleVirtualTextureNode.LodCalculation.VtLevel_Automatic,
+                out var lodCalculationVisualElement));
+
+            propertySheet.Add(enumPropertyDrawer.CreateGUI((newValue) =>
+                {
+                    if (node.sampleQuality == (SampleVirtualTextureNode.QualityMode) newValue)
+                        return;
+
+                    node.owner.owner.RegisterCompleteObjectUndo("Quality Change");
+                    node.sampleQuality = (SampleVirtualTextureNode.QualityMode) newValue;
+                },
+                node.sampleQuality,
+                "Quality",
+                SampleVirtualTextureNode.QualityMode.VtSampleQuality_High,
+                out var qualityVisualElement));
+
+            var boolPropertyDrawer = new BoolPropertyDrawer();
+            propertySheet.Add(boolPropertyDrawer.CreateGUI((newValue) =>
+                {
+                    if (node.noFeedback == newValue)
+                        return;
+
+                    node.owner.owner.RegisterCompleteObjectUndo("Feedback Settings Change");
+                    node.noFeedback = newValue;
+                },
+                node.noFeedback,
+                "No Feedback",
+                out var propertyToggle));
+
+            var vtProperty = node.GetSlotProperty(SampleVirtualTextureNode.VirtualTextureInputId) as VirtualTextureShaderProperty;
+            if (vtProperty == null)
+            {
+                propertySheet.Add(new HelpBoxRow(MessageType.Warning),
+                    (row) => row.Add(
+                        new Label("Please connect a VirtualTexture property to configure texture sampling type.")));
+            }
+            else
+            {
+                int numLayers = vtProperty.value.layers.Count;
+
+                for (int i = 0; i < numLayers; i++)
+                {
+                    int currentIndex = i; // to make lambda by-ref capturing happy
+
+                    propertySheet.Add(enumPropertyDrawer.CreateGUI((newValue) =>
+                        {
+                            if (node.textureTypes[currentIndex] == (TextureType) newValue)
+                                return;
+
+                            node.owner.owner.RegisterCompleteObjectUndo("Texture Type Change");
+                            node.textureTypes[currentIndex] = (TextureType) newValue;
+                            node.Dirty(ModificationScope.Graph);
+                        },
+                        node.textureTypes[i],
+                        "Layer " + (i + 1) + " Type",
+                        TextureType.Default,
+                        out var layersVisualElement));
+                }
+            }
+
+            propertySheet.Add(enumPropertyDrawer.CreateGUI((newValue) =>
+                {
+                    if (node.normalMapSpace == (NormalMapSpace) newValue)
+                        return;
+
+                    node.owner.owner.RegisterCompleteObjectUndo("Normal Map space Change");
+                    node.normalMapSpace = (NormalMapSpace) newValue;
+                },
+                node.normalMapSpace,
+                "Normal Space",
+                NormalMapSpace.Tangent,
+                out var normalMapSpaceVisualElement));
+
+            // display warning if the current master node doesn't support virtual texturing
+            if (!node.owner.isSubGraph)
+            {
+                bool supportedByMasterNode =
+                    node.owner.GetNodes<IMasterNode>().FirstOrDefault()?.supportsVirtualTexturing ?? false;
+                if (!supportedByMasterNode)
+                    propertySheet.Add(new HelpBoxRow(MessageType.Warning),
+                        (row) => row.Add(new Label(
+                            "The current master node does not support Virtual Texturing, this node will do regular 2D sampling.")));
+            }
+
+            // display warning if the current render pipeline doesn't support virtual texturing
+            IVirtualTexturingEnabledRenderPipeline vtRp =
+                GraphicsSettings.currentRenderPipeline as IVirtualTexturingEnabledRenderPipeline;
+            if (vtRp == null)
+                propertySheet.Add(new HelpBoxRow(MessageType.Warning),
+                    (row) => row.Add(new Label(
+                        "The current render pipeline does not support Virtual Texturing, this node will do regular 2D sampling.")));
+            else if (vtRp.virtualTexturingEnabled == false)
+                propertySheet.Add(new HelpBoxRow(MessageType.Warning),
+                    (row) => row.Add(new Label(
+                        "The current render pipeline has disabled Virtual Texturing, this node will do regular 2D sampling.")));
+            else
+            {
+#if !ENABLE_VIRTUALTEXTURES
+                propertySheet.Add(new HelpBoxRow(MessageType.Warning),
+                    (row) => row.Add(new Label(
+                        "Virtual Texturing is disabled globally (possibly by the render pipeline settings), this node will do regular 2D sampling.")));
+#endif
+            }
+
+            propertyVisualElement = propertySheet;
+            return propertySheet;
+        }
+
+        public Action inspectorUpdateDelegate { get; set; }
+
+        public VisualElement DrawProperty(PropertyInfo propertyInfo, object actualObject,
+            InspectableAttribute attribute)
+        {
+            return this.CreateGUI(
+                (SampleVirtualTextureNode) actualObject,
+                attribute,
+                out var propertyVisualElement);
+        }
+    }
+}
diff --git a/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/SampleVirtualTextureNodePropertyDrawer.cs.meta b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/SampleVirtualTextureNodePropertyDrawer.cs.meta
new file mode 100644
index 00000000000..ded09614710
--- /dev/null
+++ b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/SampleVirtualTextureNodePropertyDrawer.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4ba5078c03394fbc8daa0a30927da29d
+timeCreated: 1589579990
\ No newline at end of file
diff --git a/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/ShaderGUIOverridePropertyDrawer.cs b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/ShaderGUIOverridePropertyDrawer.cs
index 57be7eae086..00e2cdf3ccd 100644
--- a/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/ShaderGUIOverridePropertyDrawer.cs
+++ b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/ShaderGUIOverridePropertyDrawer.cs
@@ -53,7 +53,8 @@ private VisualElement CreateGUI(
             shaderGUIOverrideField = null;
 
             string storedValue = actualObject.ShaderGUIOverride;
-            string preferredGUI = GraphUtil.CurrentPipelinePreferredShaderGUI(m_MasterNode as IMasterNode);
+            string preferredGUI = String.Empty;
+            //string preferredGUI = GraphUtil.CurrentPipelinePreferredShaderGUI(m_MasterNode as IMasterNode);
 
             var boolPropertyDrawer = new BoolPropertyDrawer();
             propertySheet.Add(boolPropertyDrawer.CreateGUI(
@@ -132,7 +133,8 @@ void ProcessShaderGUIField(string newValue)
             string sanitizedInput = Regex.Replace(newValue, @"(?:[^A-Za-z0-9._])|(?:\s)", "");
             if (HasPreferredGUI() && string.IsNullOrEmpty(sanitizedInput))
             {
-                var defaultGUI = GraphUtil.CurrentPipelinePreferredShaderGUI(m_MasterNode as IMasterNode);
+                var defaultGUI = String.Empty;
+                //var defaultGUI = GraphUtil.CurrentPipelinePreferredShaderGUI(m_MasterNode as IMasterNode);
                 m_ShaderGUIOverrideInfo.ShaderGUIOverride = defaultGUI;
             }
             else
@@ -200,7 +202,8 @@ private bool ValidCustomEditorType(string customEditorName)
 
         private bool HasPreferredGUI()
         {
-            return !string.IsNullOrEmpty(GraphUtil.CurrentPipelinePreferredShaderGUI(m_MasterNode as IMasterNode));
+            return false;
+            //return !string.IsNullOrEmpty(GraphUtil.CurrentPipelinePreferredShaderGUI(m_MasterNode as IMasterNode));
         }
     }
 }
diff --git a/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/ShaderGUIOverridePropertyDrawer.cs.meta b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/ShaderGUIOverridePropertyDrawer.cs.meta
index 73a082ce3e1..8740d51980c 100644
--- a/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/ShaderGUIOverridePropertyDrawer.cs.meta
+++ b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/ShaderGUIOverridePropertyDrawer.cs.meta
@@ -1,3 +1,11 @@
-fileFormatVersion: 2
+fileFormatVersion: 2
 guid: d662a042d9df4859bba3790c65a220e1
-timeCreated: 1587149204
\ No newline at end of file
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/ShaderInputPropertyDrawer.cs b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/ShaderInputPropertyDrawer.cs
index d434f70a5c8..ef7a9635084 100644
--- a/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/ShaderInputPropertyDrawer.cs
+++ b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/ShaderInputPropertyDrawer.cs
@@ -28,7 +28,6 @@ class ShaderInputPropertyDrawer : IPropertyDrawer
         internal delegate void ChangeValueCallback(object newValue);
         internal delegate void PreChangeValueCallback(string actionName);
         internal delegate void PostChangeValueCallback(bool bTriggerPropertyUpdate = false, ModificationScope modificationScope = ModificationScope.Node);
-        internal delegate void MessageManagerCallback(string message);
 
         // Keyword
         ReorderableList m_KeywordReorderableList;
@@ -38,6 +37,9 @@ class ShaderInputPropertyDrawer : IPropertyDrawer
         ReorderableList m_VTReorderableList;
         int m_VTSelectedIndex;
 
+        private static GUIStyle greyLabel;
+
+
         // Reference Name
         TextField m_ReferenceNameField;
         public ChangeReferenceNameCallback _resetReferenceNameCallback;
@@ -45,6 +47,14 @@ class ShaderInputPropertyDrawer : IPropertyDrawer
         ShaderInput shaderInput;
 
         GraphData graphData;
+        public ShaderInputPropertyDrawer()
+        {
+            greyLabel = new GUIStyle(EditorStyles.label);
+            greyLabel.normal = new GUIStyleState { textColor = Color.grey };
+            greyLabel.focused = new GUIStyleState { textColor = Color.grey };
+            greyLabel.hover = new GUIStyleState { textColor = Color.grey };
+        }
+
         bool isSubGraph { get ; set;  }
         ChangeExposedFieldCallback _exposedFieldChangedCallback;
         ChangeReferenceNameCallback _referenceNameChangedCallback;
@@ -928,9 +938,9 @@ void KeywordAddCallbacks()
             {
                 int indent = 14;
                 var displayRect = new Rect(rect.x + indent, rect.y, (rect.width - indent) / 2, rect.height);
-                EditorGUI.LabelField(displayRect, "Display Name");
+                EditorGUI.LabelField(displayRect, "Entry Name");
                 var referenceRect = new Rect((rect.x + indent) + (rect.width - indent) / 2, rect.y, (rect.width - indent) / 2, rect.height);
-                EditorGUI.LabelField(referenceRect, "Reference Suffix");
+                EditorGUI.LabelField(referenceRect, "Reference Suffix", keyword.isBuiltIn ? EditorStyles.label : greyLabel);
             };
 
             // Draw Element
@@ -940,10 +950,11 @@ void KeywordAddCallbacks()
                 EditorGUI.BeginChangeCheck();
 
                 var displayName = EditorGUI.DelayedTextField( new Rect(rect.x, rect.y, rect.width / 2, EditorGUIUtility.singleLineHeight), entry.displayName, EditorStyles.label);
-                var referenceName = EditorGUI.DelayedTextField( new Rect(rect.x + rect.width / 2, rect.y, rect.width / 2, EditorGUIUtility.singleLineHeight), entry.referenceName, EditorStyles.label);
+                var referenceName = EditorGUI.TextField( new Rect(rect.x + rect.width / 2, rect.y, rect.width / 2, EditorGUIUtility.singleLineHeight), entry.referenceName,
+                    keyword.isBuiltIn ? EditorStyles.label : greyLabel);
 
                 displayName = GetDuplicateSafeDisplayName(entry.id, displayName);
-                referenceName = GetDuplicateSafeReferenceName(entry.id, referenceName.ToUpper());
+                referenceName = GetDuplicateSafeReferenceName(entry.id, displayName.ToUpper());
 
                 if(EditorGUI.EndChangeCheck())
                 {
diff --git a/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/SubGraphOutputNodePropertyDrawer.cs b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/SubGraphOutputNodePropertyDrawer.cs
new file mode 100644
index 00000000000..e440075d47d
--- /dev/null
+++ b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/SubGraphOutputNodePropertyDrawer.cs
@@ -0,0 +1,39 @@
+using System;
+using System.Reflection;
+using Data.Interfaces;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph;
+using UnityEditor.ShaderGraph.Drawing;
+using UnityEditor.ShaderGraph.Drawing.Inspector;
+using UnityEngine.UIElements;
+
+namespace Drawing.Inspector.PropertyDrawers
+{
+    [SGPropertyDrawer(typeof(SubGraphOutputNode))]
+    public class SubGraphOutputNodePropertyDrawer : IPropertyDrawer
+    {
+        VisualElement CreateGUI(SubGraphOutputNode node, InspectableAttribute attribute,
+            out VisualElement propertyVisualElement)
+        {
+            var propertySheet = new PropertySheet(PropertyDrawerUtils.CreateLabel(attribute.labelName));
+            var inputListView = new ReorderableSlotListView(node, SlotType.Input);
+            inputListView.OnAddCallback += list => inspectorUpdateDelegate();
+            inputListView.OnRemoveCallback += list => inspectorUpdateDelegate();
+            inputListView.OnListRecreatedCallback += () => inspectorUpdateDelegate();
+            propertySheet.Add(inputListView);
+            propertyVisualElement = propertySheet;
+            return propertySheet;
+        }
+
+        public Action inspectorUpdateDelegate { get; set; }
+
+        public VisualElement DrawProperty(PropertyInfo propertyInfo, object actualObject,
+            InspectableAttribute attribute)
+        {
+            return this.CreateGUI(
+                (SubGraphOutputNode) actualObject,
+                attribute,
+                out var propertyVisualElement);
+        }
+    }
+}
diff --git a/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/SubGraphOutputNodePropertyDrawer.cs.meta b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/SubGraphOutputNodePropertyDrawer.cs.meta
new file mode 100644
index 00000000000..bfa9e604ea9
--- /dev/null
+++ b/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/SubGraphOutputNodePropertyDrawer.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e628cecc47c94d4da6cd8ac547e1a4ef
+timeCreated: 1588810477
\ No newline at end of file
diff --git a/com.unity.shadergraph/Editor/Drawing/Views/GraphEditorView.cs b/com.unity.shadergraph/Editor/Drawing/Views/GraphEditorView.cs
index c039ec43eaf..18fe5d58b5c 100644
--- a/com.unity.shadergraph/Editor/Drawing/Views/GraphEditorView.cs
+++ b/com.unity.shadergraph/Editor/Drawing/Views/GraphEditorView.cs
@@ -23,9 +23,20 @@ namespace UnityEditor.ShaderGraph.Drawing
     [Serializable]
     class FloatingWindowsLayout
     {
-        public WindowDockingLayout previewLayout = new WindowDockingLayout();
-        public WindowDockingLayout blackboardLayout = new WindowDockingLayout();
-        public Vector2 masterPreviewSize = new Vector2(200, 200);
+        public WindowDockingLayout previewLayout = new WindowDockingLayout
+        {
+            dockingTop = false,
+            dockingLeft = false,
+            verticalOffset = 8,
+            horizontalOffset = 8
+        };
+        public WindowDockingLayout blackboardLayout = new WindowDockingLayout
+        {
+            dockingTop = true,
+            dockingLeft = true,
+            verticalOffset = 8,
+            horizontalOffset = 8
+        };
     }
 
     [Serializable]
@@ -63,7 +74,7 @@ public BlackboardProvider blackboardProvider
         internal UserViewSettings viewSettings { get => m_UserViewSettings; }
 
         const string k_FloatingWindowsLayoutKey = "UnityEditor.ShaderGraph.FloatingWindowsLayout2";
-        FloatingWindowsLayout m_FloatingWindowsLayout;
+        FloatingWindowsLayout m_FloatingWindowsLayout = new FloatingWindowsLayout();
 
         public Action saveRequested { get; set; }
 
@@ -117,41 +128,18 @@ public GraphEditorView(EditorWindow editorWindow, GraphData graph, MessageManage
             m_EditorWindow = editorWindow;
             m_Graph = graph;
             m_MessageManager = messageManager;
-            styleSheets.Add(Resources.Load<StyleSheet>("Styles/GraphEditorView"));
             previewManager = new PreviewManager(graph, messageManager);
             previewManager.onPrimaryMasterChanged = OnPrimaryMasterChanged;
+            previewManager.RenderPreviews(false);
 
             var serializedSettings = EditorUserSettings.GetConfigValue(k_UserViewSettings);
             m_UserViewSettings = JsonUtility.FromJson<UserViewSettings>(serializedSettings) ?? new UserViewSettings();
-            m_ColorManager = new ColorManager(m_UserViewSettings.colorProvider);
 
-            string serializedWindowLayout = EditorUserSettings.GetConfigValue(k_FloatingWindowsLayoutKey);
-            if (!string.IsNullOrEmpty(serializedWindowLayout))
-            {
-                m_FloatingWindowsLayout = JsonUtility.FromJson<FloatingWindowsLayout>(serializedWindowLayout);
-            }
-            else
-            {
-                m_FloatingWindowsLayout = new FloatingWindowsLayout
-                {
-                    blackboardLayout =
-                    {
-                        dockingTop = true,
-                        dockingLeft = true,
-                        verticalOffset = 8,
-                        horizontalOffset = 8,
-                        size = new Vector2(200, 400)
-                    }
-                };
-            }
+            m_ColorManager = new ColorManager(m_UserViewSettings.colorProvider);
+            var colorProviders = m_ColorManager.providerNames.ToArray();
 
-            if (m_FloatingWindowsLayout.masterPreviewSize.x > 0f && m_FloatingWindowsLayout.masterPreviewSize.y > 0f)
-            {
-                previewManager.ResizeMasterPreview(m_FloatingWindowsLayout.masterPreviewSize);
-            }
+            styleSheets.Add(Resources.Load<StyleSheet>("Styles/GraphEditorView"));
 
-            previewManager.RenderPreviews(false);
-            var colorProviders = m_ColorManager.providerNames.ToArray();
             var toolbar = new IMGUIContainer(() =>
                 {
                     GUILayout.BeginHorizontal(EditorStyles.toolbar);
@@ -172,24 +160,6 @@ public GraphEditorView(EditorWindow editorWindow, GraphData graph, MessageManage
                             showInProjectRequested();
                     }
 
-                    EditorGUI.BeginChangeCheck();
-                    GUILayout.Label("Precision");
-                    var precision = (ConcretePrecision)EditorGUILayout.EnumPopup(graph.concretePrecision, GUILayout.Width(100f));
-                    if (EditorGUI.EndChangeCheck())
-                    {
-                        m_Graph.owner.RegisterCompleteObjectUndo("Changed Graph Precision");
-                        graph.concretePrecision = precision;
-
-                        var nodeList = m_GraphView.Query<MaterialNodeView>().ToList();
-                        m_ColorManager.SetNodesDirty(nodeList);
-                        graph.ValidateGraph();
-                        m_ColorManager.UpdateNodeViews(nodeList);
-                        foreach (var node in graph.GetNodes<AbstractMaterialNode>())
-                        {
-                            node.Dirty(ModificationScope.Graph);
-                        }
-                    }
-
                     if (isCheckedOut != null)
                     {
                         if (!isCheckedOut() && Provider.enabled && Provider.isActive)
@@ -208,6 +178,12 @@ public GraphEditorView(EditorWindow editorWindow, GraphData graph, MessageManage
                         }
                     }
 
+                    GUILayout.Space(6);
+                    if (GUILayout.Button("Graph Settings", EditorStyles.toolbarButton))
+                    {
+                        m_InspectorView?.ShowGraphSettings();
+                    }
+
                     GUILayout.FlexibleSpace();
 
                     EditorGUI.BeginChangeCheck();
@@ -233,7 +209,8 @@ public GraphEditorView(EditorWindow editorWindow, GraphData graph, MessageManage
 
             var content = new VisualElement { name = "content" };
             {
-                m_GraphView = new MaterialGraphView(graph) { name = "GraphView", viewDataKey = "MaterialGraphView" };
+                m_GraphView = new MaterialGraphView(graph, () => { })
+                    { name = "GraphView", viewDataKey = "MaterialGraphView" };
                 m_GraphView.SetupZoom(0.05f, 8);
                 m_GraphView.AddManipulator(new ContentDragger());
                 m_GraphView.AddManipulator(new SelectionDragger());
@@ -243,12 +220,15 @@ public GraphEditorView(EditorWindow editorWindow, GraphData graph, MessageManage
                 RegisterGraphViewCallbacks();
                 content.Add(m_GraphView);
 
-                m_BlackboardProvider = new BlackboardProvider(graph);
-                m_GraphView.Add(m_BlackboardProvider.blackboard);
+                string serializedWindowLayout = EditorUserSettings.GetConfigValue(k_FloatingWindowsLayoutKey);
+                if (!string.IsNullOrEmpty(serializedWindowLayout))
+                {
+                    m_FloatingWindowsLayout = JsonUtility.FromJson<FloatingWindowsLayout>(serializedWindowLayout);
+                }
 
+                CreateBlackboard();
                 CreateMasterPreview();
-                // When Matt integrates his stacks work, the inspector will need to trigger preview updates
-                CreateInspector(() => { });
+                CreateInspector();
 
                 UpdateSubWindowsVisibility();
 
@@ -347,6 +327,12 @@ void UnregisterGraphViewCallbacks()
             m_GraphView.elementsRemovedFromGroup = null;
         }
 
+        void CreateBlackboard()
+        {
+            m_BlackboardProvider = new BlackboardProvider(m_Graph);
+            m_GraphView.Add(m_BlackboardProvider.blackboard);
+        }
+
         void CreateMasterPreview()
         {
             m_MasterPreviewView = new MasterPreviewView(previewManager, m_Graph) {name = "masterPreview"};
@@ -359,11 +345,10 @@ void CreateMasterPreview()
             m_MasterPreviewView.previewResizeBorderFrame.OnResizeFinished += UpdateSerializedWindowLayout;
         }
 
-        void CreateInspector(Action previewUpdateDelegate)
+        void CreateInspector()
         {
-            m_InspectorView = new InspectorView(graphView, previewUpdateDelegate);
+            m_InspectorView = new InspectorView(graphView);
             m_GraphView.Add(m_InspectorView);
-            m_GraphView.OnSelectionChange += selectedObjects => m_InspectorView.Update();
         }
 
         void OnKeyDown(KeyDownEvent evt)
@@ -602,7 +587,7 @@ public void HandleGraphChanges(bool wasUndoRedoPerformed)
 
             previewManager.RenderPreviews();
             m_BlackboardProvider.HandleGraphChanges(wasUndoRedoPerformed);
-            if(wasUndoRedoPerformed)
+            if(wasUndoRedoPerformed || m_InspectorView.DoesInspectorNeedUpdate())
                 m_InspectorView.Update();
             m_GroupHashSet.Clear();
 
@@ -1136,12 +1121,20 @@ void ApplySerializedWindowLayouts(GeometryChangedEvent evt)
 
         void ApplyMasterPreviewLayout()
         {
-            m_FloatingWindowsLayout.previewLayout.ApplyPosition(m_MasterPreviewView);
+            // If a preview size was loaded in from saved user settings use that
+            if (m_FloatingWindowsLayout.previewLayout.size.x > 0f && m_FloatingWindowsLayout.previewLayout.size.y > 0f)
+            {
+                previewManager.ResizeMasterPreview(m_FloatingWindowsLayout.previewLayout.size);
+            }
+            else // Use default specified in the stylesheet for master preview
+            {
+                m_FloatingWindowsLayout.previewLayout.size = m_MasterPreviewView.layout.size;
+            }
 
-            previewManager.ResizeMasterPreview(m_FloatingWindowsLayout.masterPreviewSize);
+            m_FloatingWindowsLayout.previewLayout.ApplyPosition(m_MasterPreviewView);
 
-            m_MasterPreviewView.previewTextureView.style.width = m_FloatingWindowsLayout.masterPreviewSize.x;
-            m_MasterPreviewView.previewTextureView.style.height = m_FloatingWindowsLayout.masterPreviewSize.y;
+            m_MasterPreviewView.style.width = m_FloatingWindowsLayout.previewLayout.size.x;
+            m_MasterPreviewView.style.height = m_FloatingWindowsLayout.previewLayout.size.y;
             m_MasterPreviewView.RegisterCallback<GeometryChangedEvent>(SerializeMasterPreviewLayout);
         }
 
@@ -1152,6 +1145,17 @@ void SerializeMasterPreviewLayout(GeometryChangedEvent evt)
 
         void ApplyBlackboardLayout()
         {
+            // If a blackboard size was loaded in from saved user settings use that
+            if (m_FloatingWindowsLayout.blackboardLayout.size.x > 0f && m_FloatingWindowsLayout.blackboardLayout.size.y > 0f)
+            {
+                blackboardProvider.blackboard.style.width = m_FloatingWindowsLayout.blackboardLayout.size.x;
+                blackboardProvider.blackboard.style.height = m_FloatingWindowsLayout.blackboardLayout.size.y;
+            }
+            else // Use default specified in the stylesheet for blackboard
+            {
+                m_FloatingWindowsLayout.blackboardLayout.size = blackboardProvider.blackboard.layout.size;
+            }
+
             // Restore blackboard layout, and make sure that it remains in the view.
             Rect blackboardRect = m_FloatingWindowsLayout.blackboardLayout.GetLayout(this.layout);
 
@@ -1185,9 +1189,11 @@ void UpdateSerializedWindowLayout()
             m_FloatingWindowsLayout.blackboardLayout.CalculateDockingCornerAndOffset(m_BlackboardProvider.blackboard.layout, m_GraphView.layout);
             m_FloatingWindowsLayout.blackboardLayout.ClampToParentWindow();
 
+            m_InspectorView.ClampToParentLayout(m_GraphView.layout);
+
             if (m_MasterPreviewView.expanded)
             {
-                m_FloatingWindowsLayout.masterPreviewSize = m_MasterPreviewView.previewTextureView.layout.size;
+                m_FloatingWindowsLayout.previewLayout.size = m_MasterPreviewView.previewTextureView.layout.size;
             }
 
             string serializedWindowLayout = JsonUtility.ToJson(m_FloatingWindowsLayout);
diff --git a/com.unity.shadergraph/Editor/Drawing/Views/GraphSubWindow.cs b/com.unity.shadergraph/Editor/Drawing/Views/GraphSubWindow.cs
index 2bbc98d278f..e31dac03254 100644
--- a/com.unity.shadergraph/Editor/Drawing/Views/GraphSubWindow.cs
+++ b/com.unity.shadergraph/Editor/Drawing/Views/GraphSubWindow.cs
@@ -5,7 +5,7 @@
 
 namespace UnityEditor.ShaderGraph.Drawing.Views
 {
-    class GraphSubWindow : GraphElement, ISelection, IResizable
+    class GraphSubWindow : GraphElement, IResizable
     {
         Dragger m_Dragger;
 
@@ -17,11 +17,9 @@ class GraphSubWindow : GraphElement, ISelection, IResizable
             dockingLeft = false,
             verticalOffset = 8,
             horizontalOffset = 8,
-            size = new Vector2(300, 300),
         };
         WindowDockingLayout windowDockingLayout { get; set; }
 
-
         protected VisualElement m_MainContainer;
         protected VisualElement m_Root;
         protected Label m_TitleLabel;
@@ -58,14 +56,7 @@ public GraphView graphView
             }
         }
 
-        // ISelection implementation
-        public List<ISelectable> selection
-        {
-            get
-            {
-                return graphView?.selection;
-            }
-        }
+        public List<ISelectable> selection => graphView?.selection;
 
         public override string title
         {
@@ -79,6 +70,7 @@ public string subTitle
             set { m_SubTitleLabel.text = value; }
         }
 
+        // Intended for future handling of docking to sides of the shader graph window
         bool m_Windowed;
         public bool windowed
         {
@@ -142,8 +134,9 @@ protected GraphSubWindow(GraphView associatedGraphView = null) : base()
             m_GraphView = associatedGraphView;
             m_GraphView.Add(this);
 
+            var styleSheet = Resources.Load<StyleSheet>($"Styles/{styleName}");
             // Setup VisualElement from Stylesheet and UXML file
-            styleSheets.Add(Resources.Load<StyleSheet>($"Styles/{styleName}"));
+            styleSheets.Add(styleSheet);
             var uxml = Resources.Load<VisualTreeAsset>($"UXML/{UxmlName}");
             m_MainContainer = uxml.Instantiate();
             m_MainContainer.AddToClassList("mainContainer");
@@ -187,26 +180,24 @@ protected GraphSubWindow(GraphView associatedGraphView = null) : base()
 
             RegisterCallback<MouseDownEvent>(e =>
             {
-                if (e.button == (int)MouseButton.LeftMouse)
-                    ClearSelection();
                 // prevent ContentDragger manipulator
                 e.StopPropagation();
             });
         }
 
-        public virtual void AddToSelection(ISelectable selectable)
-        {
-            graphView?.AddToSelection(selectable);
-        }
-
-        public virtual void RemoveFromSelection(ISelectable selectable)
+        protected void ShowWindow()
         {
-            graphView?.RemoveFromSelection(selectable);
+            this.style.visibility = Visibility.Visible;
+            contentContainer.MarkDirtyRepaint();
         }
 
-        public virtual void ClearSelection()
+        protected void HideWindow()
         {
-            graphView?.ClearSelection();
+            this.style.visibility = Visibility.Hidden;
+            this.m_ScrollView.showVertical = false;
+            this.m_ScrollView.showHorizontal = false;
+            contentContainer.Clear();
+            contentContainer.MarkDirtyRepaint();
         }
 
         void BuildManipulators()
@@ -220,22 +211,23 @@ void BuildManipulators()
             hierarchy.Add(resizeElement);
         }
 
-        void OnMoved(MouseUpEvent upEvent)
+#region Layout
+        public void ClampToParentLayout(Rect parentLayout)
         {
-            windowDockingLayout.CalculateDockingCornerAndOffset(layout, graphView.layout);
+            windowDockingLayout.CalculateDockingCornerAndOffset(layout, parentLayout);
             windowDockingLayout.ClampToParentWindow();
-
+            windowDockingLayout.ApplyPosition(this);
             SerializeLayout();
         }
 
-        void OnWindowResize(MouseUpEvent upEvent)
+        public void OnStartResize()
         {
         }
 
-        void SerializeLayout()
+        public void OnResized()
         {
-            var serializedLayout = JsonUtility.ToJson(windowDockingLayout);
-            EditorUserSettings.SetConfigValue(layoutKey, serializedLayout);
+            windowDockingLayout.size = layout.size;
+            SerializeLayout();
         }
 
         public void DeserializeLayout()
@@ -250,14 +242,25 @@ public void DeserializeLayout()
             windowDockingLayout.ApplyPosition(this);
         }
 
-        public void OnStartResize()
+        void SerializeLayout()
         {
+            windowDockingLayout.size = layout.size;
+            var serializedLayout = JsonUtility.ToJson(windowDockingLayout);
+            EditorUserSettings.SetConfigValue(layoutKey, serializedLayout);
         }
 
-        public void OnResized()
+        void OnMoved(MouseUpEvent upEvent)
         {
-            windowDockingLayout.size = layout.size;
+            windowDockingLayout.CalculateDockingCornerAndOffset(layout, graphView.layout);
+            windowDockingLayout.ClampToParentWindow();
+
             SerializeLayout();
         }
+
+        void OnWindowResize(MouseUpEvent upEvent)
+        {
+            OnResized();
+        }
     }
+#endregion
 }
diff --git a/com.unity.shadergraph/Editor/Drawing/Views/MaterialGraphView.cs b/com.unity.shadergraph/Editor/Drawing/Views/MaterialGraphView.cs
index effa733b024..9f95c6f8cb9 100644
--- a/com.unity.shadergraph/Editor/Drawing/Views/MaterialGraphView.cs
+++ b/com.unity.shadergraph/Editor/Drawing/Views/MaterialGraphView.cs
@@ -36,26 +36,23 @@ protected override bool canCopySelection
             get { return selection.OfType<IShaderNodeView>().Any(x => x.node.canCopyNode) || selection.OfType<Group>().Any() || selection.OfType<BlackboardField>().Any(); }
         }
 
-        public MaterialGraphView(GraphData graph) : this()
+        public MaterialGraphView(GraphData graph, Action previewUpdateDelegate) : this()
         {
             this.graph = graph;
+            this.m_PreviewManagerUpdateDelegate = previewUpdateDelegate;
         }
 
         [Inspectable("GraphData", null)]
         public GraphData graph { get; private set; }
 
         Action m_InspectorUpdateDelegate;
+        Action m_PreviewManagerUpdateDelegate;
 
         public string inspectorTitle => this.graph.path;
 
         public object GetObjectToInspect()
         {
-            return this.graph;
-        }
-
-        public PropertyInfo[] GetPropertyInfo()
-        {
-            return this.GetType().GetProperties();
+            return graph;
         }
 
         public void SupplyDataToPropertyDrawer(IPropertyDrawer propertyDrawer, Action inspectorUpdateDelegate)
@@ -63,14 +60,10 @@ public void SupplyDataToPropertyDrawer(IPropertyDrawer propertyDrawer, Action in
             m_InspectorUpdateDelegate = inspectorUpdateDelegate;
             if (propertyDrawer is GraphDataPropertyDrawer graphDataPropertyDrawer)
             {
-                graphDataPropertyDrawer.GetPropertyData(this.ChangeTargetSettings, ChangeConcretePrecision);
+                graphDataPropertyDrawer.GetPropertyData(ChangeConcretePrecision);
             }
         }
 
-        void ChangeTargetSettings()
-        {
-            this.m_InspectorUpdateDelegate();
-        }
         void ChangeConcretePrecision(ConcretePrecision newValue)
         {
             var graphEditorView = this.GetFirstAncestorOfType<GraphEditorView>();
diff --git a/com.unity.shadergraph/Editor/Drawing/Views/MaterialNodeView.cs b/com.unity.shadergraph/Editor/Drawing/Views/MaterialNodeView.cs
index 2aead237eaf..41c2d7d81a2 100644
--- a/com.unity.shadergraph/Editor/Drawing/Views/MaterialNodeView.cs
+++ b/com.unity.shadergraph/Editor/Drawing/Views/MaterialNodeView.cs
@@ -8,6 +8,7 @@
 using UnityEditor.ShaderGraph.Drawing.Controls;
 using UnityEngine.Rendering;
 using Data.Interfaces;
+using Drawing.Inspector.PropertyDrawers;
 using UnityEditor.Experimental.GraphView;
 using UnityEditor.Rendering;
 using UnityEditor.ShaderGraph.Drawing.Inspector.PropertyDrawers;
@@ -40,7 +41,6 @@ sealed class MaterialNodeView : Node, IShaderNodeView, IInspectable
 
         MaterialGraphView m_GraphView;
 
-        public string inspectorTitle => $"{node.name} (Node)";
         public void Initialize(AbstractMaterialNode inNode, PreviewManager previewManager, IEdgeConnectorListener connectorListener, MaterialGraphView graphView)
         {
             styleSheets.Add(Resources.Load<StyleSheet>("Styles/MaterialNodeView"));
@@ -180,36 +180,36 @@ public void Initialize(AbstractMaterialNode inNode, PreviewManager previewManage
                                           " Assign a Render Pipeline in the graphics settings that is compatible with this Master Node.",
                             ShaderCompilerMessageSeverity.Error));
                 }
-            }
 
-            m_NodeSettingsView = new NodeSettingsView();
-            m_NodeSettingsView.visible = false;
-            Add(m_NodeSettingsView);
+                m_NodeSettingsView = new NodeSettingsView();
+                m_NodeSettingsView.visible = false;
+                Add(m_NodeSettingsView);
 
-            m_SettingsButton = new VisualElement {name = "settings-button"};
+                m_SettingsButton = new VisualElement {name = "settings-button"};
                 m_SettingsButton.Add(new VisualElement {name = "icon"});
 
-            m_Settings = new VisualElement();
-            AddDefaultSettings();
+                m_Settings = new VisualElement();
+                AddDefaultSettings();
 
-            // Add Node type specific settings
-            var nodeTypeSettings = node as IHasSettings;
-            if (nodeTypeSettings != null)
-                m_Settings.Add(nodeTypeSettings.CreateSettingsElement());
+                // Add Node type specific settings
+                var nodeTypeSettings = node as IMasterNode;
+                if (nodeTypeSettings != null)
+                    m_Settings.Add(nodeTypeSettings.CreateSettingsElement());
 
-            // Add manipulators
-            m_SettingsButton.AddManipulator(new Clickable(() =>
+                // Add manipulators
+                m_SettingsButton.AddManipulator(new Clickable(() =>
                 {
                     UpdateSettingsExpandedState();
                 }));
 
-            if(m_Settings.childCount > 0)
-            {
+                if(m_Settings.childCount > 0)
+                {
                     m_ButtonContainer = new VisualElement {name = "button-container"};
-                m_ButtonContainer.style.flexDirection = FlexDirection.Row;
-                m_ButtonContainer.Add(m_SettingsButton);
-                m_ButtonContainer.Add(m_CollapseButton);
-                m_TitleContainer.Add(m_ButtonContainer);
+                    m_ButtonContainer.style.flexDirection = FlexDirection.Row;
+                    m_ButtonContainer.Add(m_SettingsButton);
+                    m_ButtonContainer.Add(m_CollapseButton);
+                    m_TitleContainer.Add(m_ButtonContainer);
+                }
             }
 
             // Register OnMouseHover callbacks for node highlighting
@@ -286,6 +286,8 @@ void OnSubGraphDoubleClick(MouseDownEvent evt)
         }
 
         public Node gvNode => this;
+
+        [Inspectable("Node", null)]
         public AbstractMaterialNode node { get; private set; }
 
         public override bool expanded
@@ -416,7 +418,7 @@ void RecreateSettings()
             AddDefaultSettings();
 
             // Add Node type specific settings
-            var nodeTypeSettings = node as IHasSettings;
+            var nodeTypeSettings = node as IMasterNode;
             if (nodeTypeSettings != null)
                 m_Settings.Add(nodeTypeSettings.CreateSettingsElement());
 
@@ -443,20 +445,34 @@ void UpdateSettingsExpandedState()
             }
         }
 
+        void SetNodesAsDirty()
+        {
+            var editorView = GetFirstAncestorOfType<GraphEditorView>();
+            var nodeList = m_GraphView.Query<MaterialNodeView>().ToList();
+            editorView.colorManager.SetNodesDirty(nodeList);
+        }
 
-        public object GetObjectToInspect()
+        void UpdateNodeViews()
         {
-            return this.node;
+            var editorView = GetFirstAncestorOfType<GraphEditorView>();
+            var nodeList = m_GraphView.Query<MaterialNodeView>().ToList();
+            editorView.colorManager.UpdateNodeViews(nodeList);
         }
 
-        public PropertyInfo[] GetPropertyInfo()
+        public string inspectorTitle => $"{node.name} (Node)";
+
+        public object GetObjectToInspect()
         {
-            return this.node.GetType().GetProperties();
+            return node;
         }
 
         public void SupplyDataToPropertyDrawer(IPropertyDrawer propertyDrawer, Action inspectorUpdateDelegate)
         {
-            if (propertyDrawer is ShaderGUIOverridePropertyDrawer shaderGuiOverridePropertyDrawer)
+            if (propertyDrawer is AbstractMaterialNodePropertyDrawer nodePropertyDrawer)
+            {
+                nodePropertyDrawer.GetPropertyData(SetNodesAsDirty, UpdateNodeViews);
+            }
+            else if (propertyDrawer is ShaderGUIOverridePropertyDrawer shaderGuiOverridePropertyDrawer)
             {
                 shaderGuiOverridePropertyDrawer.GetPropertyData(node);
             }
@@ -545,8 +561,6 @@ public void OnModified(ModificationScope scope)
             // Update slots to match node modification
             if (scope == ModificationScope.Topological)
             {
-                RecreateSettings();
-
                 var slots = node.GetSlots<MaterialSlot>().ToList();
 
                 var inputPorts = inputContainer.Children().OfType<ShaderPort>().ToList();
diff --git a/com.unity.shadergraph/Editor/Drawing/Views/PropertyNodeView.cs b/com.unity.shadergraph/Editor/Drawing/Views/PropertyNodeView.cs
index b08e5079d62..4c1999f253a 100644
--- a/com.unity.shadergraph/Editor/Drawing/Views/PropertyNodeView.cs
+++ b/com.unity.shadergraph/Editor/Drawing/Views/PropertyNodeView.cs
@@ -63,12 +63,6 @@ public object GetObjectToInspect()
             return property;
         }
 
-        public PropertyInfo[] GetPropertyInfo()
-        {
-            // The AbstractShaderProperty is declared as private here so we're specifying the NonPublic flag
-            return this.GetType().GetProperties(BindingFlags.NonPublic | BindingFlags.Instance);
-        }
-
         public void SupplyDataToPropertyDrawer(IPropertyDrawer propertyDrawer, Action inspectorUpdateDelegate)
         {
             if(propertyDrawer is ShaderInputPropertyDrawer shaderInputPropertyDrawer)
diff --git a/com.unity.shadergraph/Editor/Drawing/Views/ReorderableSlotListView.cs b/com.unity.shadergraph/Editor/Drawing/Views/ReorderableSlotListView.cs
index 7c9200cf27e..6e7a94e6bf3 100644
--- a/com.unity.shadergraph/Editor/Drawing/Views/ReorderableSlotListView.cs
+++ b/com.unity.shadergraph/Editor/Drawing/Views/ReorderableSlotListView.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using UnityEngine;
@@ -9,13 +10,35 @@ namespace UnityEditor.ShaderGraph.Drawing
 {
     internal class ReorderableSlotListView : VisualElement
     {
-        private AbstractMaterialNode m_Node;
-        private SlotType m_SlotType;
-        private ReorderableList m_ReorderableList;
-        private IMGUIContainer m_Container;
-        private GUIStyle m_LabelStyle;
-        private int m_SelectedIndex = -1;
-        private string label => string.Format("{0}s", m_SlotType.ToString());
+        int m_SelectedIndex = -1;
+        SlotType m_SlotType;
+        GUIStyle m_LabelStyle;
+        IMGUIContainer m_Container;
+        AbstractMaterialNode m_Node;
+        ReorderableList m_ReorderableList;
+
+        internal delegate void ListRecreatedDelegate();
+        ListRecreatedDelegate m_OnListRecreatedCallback = new ListRecreatedDelegate(() => { });
+
+        string label => string.Format("{0}s", m_SlotType.ToString());
+
+        public ReorderableList.AddCallbackDelegate OnAddCallback
+        {
+            get => m_ReorderableList?.onAddCallback;
+            set => m_ReorderableList.onAddCallback = value;
+        }
+
+        public ReorderableList.RemoveCallbackDelegate OnRemoveCallback
+        {
+            get => m_ReorderableList.onRemoveCallback;
+            set => m_ReorderableList.onRemoveCallback = value;
+        }
+
+        public ListRecreatedDelegate OnListRecreatedCallback
+        {
+            get => m_OnListRecreatedCallback;
+            set => m_OnListRecreatedCallback = value;
+        }
 
         internal ReorderableSlotListView(AbstractMaterialNode node, SlotType slotType)
         {
@@ -24,6 +47,8 @@ internal ReorderableSlotListView(AbstractMaterialNode node, SlotType slotType)
             m_SlotType = slotType;
             m_Container = new IMGUIContainer(() => OnGUIHandler ()) { name = "ListContainer" };
             Add(m_Container);
+            RecreateList();
+            AddCallbacks();
         }
 
         internal void RecreateList()
@@ -34,10 +59,11 @@ internal void RecreateList()
                 m_Node.GetInputSlots(slots);
             else
                 m_Node.GetOutputSlots(slots);
-            
+
             // Create reorderable list from IDs
             List<int> slotIDs = slots.Select(s => s.id).ToList();
             m_ReorderableList = new ReorderableList(slotIDs, typeof(int), true, true, true, true);
+            m_OnListRecreatedCallback();
         }
 
         private void OnGUIHandler()
@@ -58,29 +84,29 @@ private void OnGUIHandler()
             }
         }
 
-        private void AddCallbacks() 
-        {      
-            m_ReorderableList.drawHeaderCallback = (Rect rect) => 
-            {  
+        private void AddCallbacks()
+        {
+            m_ReorderableList.drawHeaderCallback = (Rect rect) =>
+            {
                 var labelRect = new Rect(rect.x, rect.y, rect.width-10, rect.height);
                 EditorGUI.LabelField(labelRect, label);
             };
 
             // Draw Element
-            m_ReorderableList.drawElementCallback = (Rect rect, int index, bool isActive, bool isFocused) => 
+            m_ReorderableList.drawElementCallback = (Rect rect, int index, bool isActive, bool isFocused) =>
             {
                 // Slot is guaranteed to exist in this UI state
                 MaterialSlot oldSlot = m_Node.FindSlot<MaterialSlot>((int)m_ReorderableList.list[index]);
 
                 EditorGUI.BeginChangeCheck();
-                
-                var displayName = EditorGUI.DelayedTextField( new Rect(rect.x, rect.y, rect.width / 2, EditorGUIUtility.singleLineHeight), oldSlot.RawDisplayName(), EditorStyles.label); 
+
+                var displayName = EditorGUI.DelayedTextField( new Rect(rect.x, rect.y, rect.width / 2, EditorGUIUtility.singleLineHeight), oldSlot.RawDisplayName(), EditorStyles.label);
                 var shaderOutputName = NodeUtils.GetHLSLSafeName(displayName);
                 var concreteValueType = (ConcreteSlotValueType)EditorGUI.EnumPopup( new Rect(rect.x + rect.width / 2, rect.y, rect.width - rect.width / 2, EditorGUIUtility.singleLineHeight), oldSlot.concreteValueType);
 
                 if(displayName != oldSlot.RawDisplayName())
                     displayName = NodeUtils.GetDuplicateSafeNameForSlot(m_Node, oldSlot.id, displayName);
-                
+
                 if(EditorGUI.EndChangeCheck())
                 {
                     // Cant modify existing slots so need to create new and copy values
@@ -117,11 +143,11 @@ private void AddCallbacks()
 
                     RecreateList();
                     m_Node.ValidateNode();
-                }   
+                }
             };
 
             // Element height
-            m_ReorderableList.elementHeightCallback = (int indexer) => 
+            m_ReorderableList.elementHeightCallback = (int indexer) =>
             {
                 return m_ReorderableList.elementHeight;
             };
@@ -141,13 +167,12 @@ private void SelectEntry(ReorderableList list)
         private void AddEntry(ReorderableList list)
         {
             m_Node.owner.owner.RegisterCompleteObjectUndo("Add Port");
-
             // Need to get all current slots to get the next valid ID
             List<MaterialSlot> slots = new List<MaterialSlot>();
             m_Node.GetSlots(slots);
             int[] slotIDs = slots.Select(s => s.id).OrderByDescending(s => s).ToArray();
             int newSlotID = slotIDs.Length > 0 ? slotIDs[0] + 1 : 0;
-            
+
             string name = NodeUtils.GetDuplicateSafeNameForSlot(m_Node, newSlotID, "New");
 
             // Create a new slot and add it
@@ -178,7 +203,7 @@ private void RemoveEntry(ReorderableList list)
         private void ReorderEntries(ReorderableList list)
         {
             m_Node.owner.owner.RegisterCompleteObjectUndo("Reorder Ports");
-            
+
             // Get all the current slots
             List<MaterialSlot> slots = new List<MaterialSlot>();
             if(m_SlotType == SlotType.Input)
@@ -197,7 +222,7 @@ private void ReorderEntries(ReorderableList list)
 
             // Order them by their slot ID
             slots = slots.OrderBy(s => s.id).ToList();
-            
+
             // Now add the slots back based on the list order
             // For each list entry get the slot with that ID
             for (int i = 0; i < list.list.Count; i++)
diff --git a/com.unity.shadergraph/Editor/Drawing/Views/ReorderableTextListView.cs b/com.unity.shadergraph/Editor/Drawing/Views/ReorderableTextListView.cs
new file mode 100644
index 00000000000..235a4949d0f
--- /dev/null
+++ b/com.unity.shadergraph/Editor/Drawing/Views/ReorderableTextListView.cs
@@ -0,0 +1,123 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditorInternal;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace Drawing.Views
+{
+    internal class ReorderableListView<T> : VisualElement
+    {
+        ReorderableList m_ReorderableList;
+        List<string> m_TextList = new List<string>();
+        List<T> m_DataList;
+        IMGUIContainer m_Container;
+        GUIStyle m_LabelStyle;
+        int m_SelectedIndex = -1;
+        string headerLabel => "Reorder data:";
+
+        public List<string> TextList => m_TextList;
+
+        internal delegate void ListReorderedDelegate(IList<T> reorderedList);
+        public ListReorderedDelegate OnListReorderedCallback;
+
+        internal ReorderableListView(List<T> dataList)
+        {
+            m_DataList = dataList;
+            try
+            {
+                foreach (var data in dataList)
+                {
+                    m_TextList.Add(data.ToString());
+                }
+            }
+            catch (Exception e)
+            {
+                Debug.Log("Exception: " + e.ToString() + " while handling ReorderableListView of type: " + typeof(T).ToString());
+            }
+
+            styleSheets.Add(Resources.Load<StyleSheet>("Styles/ReorderableSlotListView"));
+            m_Container = new IMGUIContainer(() => OnGUIHandler()) {name = "ListContainer"};
+            Add(m_Container);
+        }
+
+        internal void RecreateList(List<T> dataList)
+        {
+            m_DataList = dataList;
+            // Create reorderable list from data list
+            m_ReorderableList = new ReorderableList(dataList, typeof(int), true, true, true, true);
+            m_ReorderableList.displayAdd = false;
+            m_ReorderableList.displayRemove = false;
+        }
+
+        private void OnGUIHandler()
+        {
+            try
+            {
+                if (m_ReorderableList == null)
+                {
+                    RecreateList(m_DataList);
+                    AddCallbacks();
+                }
+
+                using (var changeCheckScope = new EditorGUI.ChangeCheckScope())
+                {
+                    m_ReorderableList.index = m_SelectedIndex;
+                    m_ReorderableList.DoLayoutList();
+
+                    if (changeCheckScope.changed)
+                    {
+                        // Do things when changed
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                Debug.Log("Exception: " + e.ToString() + " while handling ReorderableListView of type: " + typeof(T).ToString());
+            }
+        }
+
+        private void AddCallbacks()
+        {
+            m_ReorderableList.drawHeaderCallback = (Rect rect) =>
+            {
+                var labelRect = new Rect(rect.x, rect.y, rect.width - 10, rect.height);
+                EditorGUI.LabelField(labelRect, headerLabel);
+            };
+
+            // Draw Element
+            m_ReorderableList.drawElementCallback = (Rect rect, int index, bool isActive, bool isFocused) =>
+            {
+                EditorGUI.BeginChangeCheck();
+                EditorGUI.LabelField(
+                    new Rect(rect.x, rect.y, rect.width / 2, EditorGUIUtility.singleLineHeight),
+                    m_TextList[index], EditorStyles.label);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    RecreateList(m_DataList);
+                }
+            };
+
+            // Element height
+            m_ReorderableList.elementHeightCallback = (int indexer) => { return m_ReorderableList.elementHeight; };
+
+            // Add callback delegates
+            m_ReorderableList.onSelectCallback += SelectEntry;
+            m_ReorderableList.onReorderCallback += ReorderEntries;
+        }
+
+        private void SelectEntry(ReorderableList list)
+        {
+            m_SelectedIndex = list.index;
+        }
+
+        private void ReorderEntries(ReorderableList list)
+        {
+            var concreteList = (List<T>) list.list;
+            RecreateList(concreteList);
+            OnListReorderedCallback(concreteList);
+        }
+    }
+}
+
diff --git a/com.unity.shadergraph/Editor/Drawing/Views/ReorderableTextListView.cs.meta b/com.unity.shadergraph/Editor/Drawing/Views/ReorderableTextListView.cs.meta
new file mode 100644
index 00000000000..fa84e724065
--- /dev/null
+++ b/com.unity.shadergraph/Editor/Drawing/Views/ReorderableTextListView.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: cba41fbec6264db1acb8a265a70cc038
+timeCreated: 1589241013
\ No newline at end of file
diff --git a/com.unity.shadergraph/Editor/Generation/Interface/IMasterNode.cs b/com.unity.shadergraph/Editor/Generation/Interface/IMasterNode.cs
index 77135ffe0ae..b8956b51416 100644
--- a/com.unity.shadergraph/Editor/Generation/Interface/IMasterNode.cs
+++ b/com.unity.shadergraph/Editor/Generation/Interface/IMasterNode.cs
@@ -2,6 +2,7 @@
 using UnityEngine;
 using UnityEngine.Rendering;
 using UnityEditor.ShaderGraph;
+using UnityEngine.UIElements;
 
 namespace UnityEditor.ShaderGraph
 {
@@ -16,5 +17,8 @@ internal interface IMasterNode
 
         ConditionalField[] GetConditionalFields(PassDescriptor pass);
         void ProcessPreviewMaterial(Material material);
+
+        // NOTE: Remove when stacks are integrated, this is only here as a stopgap measure as IHasSettings has been removed
+        VisualElement CreateSettingsElement();
     }
 }
diff --git a/com.unity.shadergraph/Editor/Resources/Resizable.uss b/com.unity.shadergraph/Editor/Resources/Resizable.uss
index 8eaac18f6ec..f7dc09a7cee 100644
--- a/com.unity.shadergraph/Editor/Resources/Resizable.uss
+++ b/com.unity.shadergraph/Editor/Resources/Resizable.uss
@@ -11,7 +11,7 @@ ResizableElement
 
 ResizableElement #right
 {
-    width: 12px;
+    width: 4px;
     flex-direction: column;
     align-items: stretch;
 }
@@ -61,7 +61,7 @@ ResizableElement #middle #middle-center
 
 ResizableElement #middle #bottom-resize
 {
-    height: 12px;
+    height: 4px;
     cursor: resize-vertical;
 }
 
diff --git a/com.unity.shadergraph/Editor/Resources/Styles/Blackboard.uss b/com.unity.shadergraph/Editor/Resources/Styles/Blackboard.uss
index 4ab57742ffe..2f006628e73 100644
--- a/com.unity.shadergraph/Editor/Resources/Styles/Blackboard.uss
+++ b/com.unity.shadergraph/Editor/Resources/Styles/Blackboard.uss
@@ -7,6 +7,8 @@
     flex-direction: column;
     background-color: #2b2b2b;
     border-color: #191919;
+    width: 100px;
+    height: 300px;
     min-width: 100px;
     min-height: 100px;
 }
diff --git a/com.unity.shadergraph/Editor/Resources/Styles/GraphSubWindow.uss b/com.unity.shadergraph/Editor/Resources/Styles/GraphSubWindow.uss
index 5383da9d6ec..99fbc293b62 100644
--- a/com.unity.shadergraph/Editor/Resources/Styles/GraphSubWindow.uss
+++ b/com.unity.shadergraph/Editor/Resources/Styles/GraphSubWindow.uss
@@ -15,8 +15,8 @@
     border-color: #191919;
     min-width: 100px;
     min-height: 100px;
-    width: 300px;
-    height: 300px;
+    width: 200px;
+    height: 200px;
 }
 
 .GraphSubWindow.windowed {
diff --git a/com.unity.shadergraph/Editor/Resources/Styles/InspectorView.uss b/com.unity.shadergraph/Editor/Resources/Styles/InspectorView.uss
index c8de3ec0960..ccd6137f8c3 100644
--- a/com.unity.shadergraph/Editor/Resources/Styles/InspectorView.uss
+++ b/com.unity.shadergraph/Editor/Resources/Styles/InspectorView.uss
@@ -17,7 +17,7 @@
     min-width: 100px;
     min-height: 100px;
     width: 300px;
-    height: 300px;
+    height: 200px;
 }
 
 .InspectorView > .mainContainer {
diff --git a/com.unity.shadergraph/Editor/Resources/Styles/MasterPreviewView.uss b/com.unity.shadergraph/Editor/Resources/Styles/MasterPreviewView.uss
index 96c533394f6..a36499d182a 100644
--- a/com.unity.shadergraph/Editor/Resources/Styles/MasterPreviewView.uss
+++ b/com.unity.shadergraph/Editor/Resources/Styles/MasterPreviewView.uss
@@ -3,6 +3,8 @@ MasterPreviewView {
     position: absolute;
     right: 10px;
     bottom: 10px;
+    width: 225px;
+    height: 225px;
     background-color: rgb(79, 79, 79);
     justify-content: flex-start;
     border-radius: 6px;
@@ -23,12 +25,9 @@ MasterPreviewView > #top {
 }
 
 MasterPreviewView > #top > #title {
-    font-size: 12px;
+    font-size: 14px;
     color: rgb(180, 180, 180);
-    padding-top: 1px;
-    padding-bottom: 2px;
-    padding-left: 2px;
-    padding-right: 2px;
+    padding: 1px 2px 2px;
 }
 
 MasterPreviewView > #top > #collapse-container {
@@ -60,6 +59,7 @@ MasterPreviewView > #top > #collapse-container > #icon.expanded {
 }
 
 MasterPreviewView > #middle {
+    background-color: rgb(49, 49, 49);
     flex-grow: 1;
     flex-direction: row;
 }
diff --git a/com.unity.shadergraph/Editor/Resources/Styles/PropertyRow.uss b/com.unity.shadergraph/Editor/Resources/Styles/PropertyRow.uss
index 4603a455220..cc07af04aec 100644
--- a/com.unity.shadergraph/Editor/Resources/Styles/PropertyRow.uss
+++ b/com.unity.shadergraph/Editor/Resources/Styles/PropertyRow.uss
@@ -17,7 +17,7 @@ PropertyRow > #container{
 }
 
 PropertyRow > #container > #label {
-    width: 92px;
+    width: 95px;
     font-size: 12px;
     margin-right: 4px;
     justify-content: center;
diff --git a/com.unity.shadergraph/Editor/Resources/Styles/PropertySheet.uss b/com.unity.shadergraph/Editor/Resources/Styles/PropertySheet.uss
index 91c0caffcab..be08283af0e 100644
--- a/com.unity.shadergraph/Editor/Resources/Styles/PropertySheet.uss
+++ b/com.unity.shadergraph/Editor/Resources/Styles/PropertySheet.uss
@@ -1,6 +1,9 @@
 PropertySheet {
     margin-top: 4px;
     margin-bottom: 4px;
+    border-width: 0.5px;
+    border-bottom-left-radius: 5px;
+    border-bottom-right-radius: 5px;
 }
 PropertySheet > #content > #header{
     margin-left: 4px;
@@ -22,3 +25,7 @@ PropertySheet > #content > #header > Label{
     font-size: 11px;
     -unity-font-style: bold;
 }
+
+PropertySheet > #content > #foldout {
+    margin-left: 21px;
+}