Merge branch 'master' into warning-incompatible-pipeline

.gitattributes

 *.png filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text

HDPipeline/HDUnlitSubShader.cs

 using System.IO;
 using System.Linq;
 using UnityEditor.Graphing;
+using UnityEngine.Experimental.UIElements;
 
 namespace UnityEditor.ShaderGraph
 {
                 if (slot != null)
                     slots.Add(slot);
             }
+
             GraphUtil.GenerateSurfaceDescriptionStruct(surfaceDescriptionStruct, slots, true);
 
             var usedSlots = new List<MaterialSlot>();
             foreach (var slot in usedSlots)
             {
                 surfaceOutputRemap.AddShaderChunk(slot.shaderOutputName
-                                                  + " = surf."
-                                                  + slot.shaderOutputName + ";", true);
+                    + " = surf."
+                    + slot.shaderOutputName + ";", true);
             }
 
             if (!File.Exists(templateLocation))

com.unity.shadergraph/Editor/Data/Graphs/AbstractMaterialGraph.cs

         public string SanitizePropertyName(string displayName, Guid guid = default(Guid))
         {
             displayName = displayName.Trim();
-            if (m_Properties.Any(p => p.displayName == displayName && p.guid != guid))
-            {
-                // Strip out the " (n)" part of the name.
-                var baseRegex = new Regex(@"^(.*) \((\d+)\)$");
-                var baseMatch = baseRegex.Match(displayName);
-                if (baseMatch.Success)
-                    displayName = baseMatch.Groups[1].Value;
+            return GraphUtil.SanitizeName(m_Properties.Where(p => p.guid != guid).Select(p => p.displayName), "{0} ({1})", displayName);
+        }
-                var regex = new Regex(@"^" + Regex.Escape(displayName) + @" \((\d+)\)$");
-                var existingDuplicateNumbers = m_Properties.Where(p => p.guid != guid).Select(p => regex.Match(p.displayName)).Where(m => m.Success).Select(m => int.Parse(m.Groups[1].Value)).Where(n => n > 0).Distinct().ToList();
+        public string SanitizePropertyReferenceName(string referenceName, Guid guid = default(Guid))
+        {
+            referenceName = referenceName.Trim();
+
+            if (string.IsNullOrEmpty(referenceName))
+                return null;
+
+            if (!referenceName.StartsWith("_"))
+                referenceName = "_" + referenceName;
-                var duplicateNumber = 1;
-                existingDuplicateNumbers.Sort();
-                if (existingDuplicateNumbers.Any() && existingDuplicateNumbers.First() == 1)
-                {
-                    duplicateNumber = existingDuplicateNumbers.Last() + 1;
-                    for (var i = 1; i < existingDuplicateNumbers.Count; i++)
-                    {
-                        if (existingDuplicateNumbers[i - 1] != existingDuplicateNumbers[i] - 1)
-                        {
-                            duplicateNumber = existingDuplicateNumbers[i - 1] + 1;
-                            break;
-                        }
-                    }
-                }
-                displayName = string.Format("{0} ({1})", displayName, duplicateNumber);
-            }
+            referenceName = Regex.Replace(referenceName, @"(?:[^A-Za-z_0-9])|(?:\s)", "_");
-            return displayName;
+            return GraphUtil.SanitizeName(m_Properties.Where(p => p.guid != guid).Select(p => p.referenceName), "{0}_{1}", referenceName);
         }
 
         public void RemoveShaderProperty(Guid guid)
             var nodeGuidMap = new Dictionary<Guid, Guid>();
             foreach (var node in graphToPaste.GetNodes<INode>())
             {
+                INode pastedNode = node;
+
+                // Check if the property nodes need to be made into a concrete node.
+                if (node is PropertyNode)
+                {
+                    PropertyNode propertyNode = (PropertyNode)node;
+
+                    // If the property is not in the current graph, do check if the
+                    // property can be made into a concrete node.
+                    if (!m_Properties.Select(x => x.guid).Contains(propertyNode.propertyGuid))
+                    {
+                        // If the property is in the serialized paste graph, make the property node into a property node.
+                        var pastedGraphMetaProperties = graphToPaste.metaProperties.Where(x => x.guid == propertyNode.propertyGuid);
+                        if (pastedGraphMetaProperties.Any())
+                        {
+                            pastedNode = pastedGraphMetaProperties.FirstOrDefault().ToConcreteNode();
+                            pastedNode.drawState = node.drawState;
+                            nodeGuidMap[oldGuid] = pastedNode.guid;
+                        }
+                    }
+                }
+
                 var drawState = node.drawState;
                 var position = drawState.position;
                 position.x += 30;
-                remappedNodes.Add(node);
-                AddNode(node);
+                remappedNodes.Add(pastedNode);
+                AddNode(pastedNode);
-                m_PastedNodes.Add(node);
+                m_PastedNodes.Add(pastedNode);
             }
 
             // only connect edges within pasted elements, discard

com.unity.shadergraph/Editor/Data/Graphs/AbstractShaderProperty.cs

             }
         }
 
-        public string overrideReferenceName { get; set; }
+        [SerializeField]
+        string m_OverrideReferenceName;
+
+        public string overrideReferenceName
+        {
+            get { return m_OverrideReferenceName; }
+            set { m_OverrideReferenceName = value; }
+        }
 
         public abstract PropertyType propertyType { get; }
 
 
         public abstract PreviewProperty GetPreviewMaterialProperty();
         public abstract INode ToConcreteNode();
+        public abstract IShaderProperty Copy();
     }
 }

com.unity.shadergraph/Editor/Data/Graphs/BooleanShaderProperty.cs

 
         public override INode ToConcreteNode()
         {
-            return new BooleanNode { value = new Toggle(value) };
+            return new BooleanNode { value = new ToggleData(value) };
+        }
+
+        public override IShaderProperty Copy()
+        {
+            var copied = new BooleanShaderProperty();
+            copied.displayName = displayName;
+            copied.value = value;
+            return copied;
         }
     }
 }

com.unity.shadergraph/Editor/Data/Graphs/ColorShaderProperty.cs

         {
             return new ColorNode { color = new ColorNode.Color(value, colorMode) };
         }
+
+        public override IShaderProperty Copy()
+        {
+            var copied = new ColorShaderProperty();
+            copied.displayName = displayName;
+            copied.value = value;
+            return copied;
+        }
     }
 }

com.unity.shadergraph/Editor/Data/Graphs/CubemapShaderProperty.cs

         {
             return new CubemapAssetNode { cubemap = value.cubemap };
         }
+
+        public override IShaderProperty Copy()
+        {
+            var copied = new CubemapShaderProperty();
+            copied.displayName = displayName;
+            copied.value = value;
+            return copied;
+        }
     }
 }

com.unity.shadergraph/Editor/Data/Graphs/GradientShaderProperty.cs

 
         public static Vector4 ColorKeyToVector(GradientColorKey key)
         {
-            return new Vector4( key.color.r, key.color.g, key.color.b, key.time); 
+            return new Vector4( key.color.r, key.color.g, key.color.b, key.time);
-            return new Vector2( key.alpha, key.time); 
+            return new Vector2( key.alpha, key.time);
         }
     }
 
             m_OverrideMembers = true;
             m_OverrideSlotName = slotName;
         }
-        
+
         public override string GetPropertyDeclarationString(string delimiter = ";")
         {
             if(m_OverrideMembers)
         {
             return new GradientNode { gradient = value };
         }
+
+        public override IShaderProperty Copy()
+        {
+            return new GradientShaderProperty
+            {
+                value = value
+            };
+        }
-}
+}

com.unity.shadergraph/Editor/Data/Graphs/IShaderProperty.cs

 
         PreviewProperty GetPreviewMaterialProperty();
         INode ToConcreteNode();
+        IShaderProperty Copy();
     }
 }

com.unity.shadergraph/Editor/Data/Graphs/Matrix2ShaderProperty.cs

                 row0 = new Vector2(value.m00, value.m01), 
                 row1 = new Vector2(value.m10, value.m11)
             };
-        } 
+        }
+
+        public override IShaderProperty Copy()
+        {
+            var copied = new Matrix2ShaderProperty();
+            copied.displayName = displayName;
+            copied.value = value;
+            return copied;
+        }
     }
 }

com.unity.shadergraph/Editor/Data/Graphs/Matrix3ShaderProperty.cs

                 row2 = new Vector3(value.m20, value.m21, value.m22)
             };
         }
+
+        public override IShaderProperty Copy()
+        {
+            var copied = new Matrix3ShaderProperty();
+            copied.displayName = displayName;
+            copied.value = value;
+            return copied;
+        }
     }
 }

com.unity.shadergraph/Editor/Data/Graphs/Matrix4ShaderProperty.cs

                 row3 = new Vector4(value.m30, value.m31, value.m32, value.m33)
             };
         }
+
+        public override IShaderProperty Copy()
+        {
+            var copied = new Matrix4ShaderProperty();
+            copied.displayName = displayName;
+            copied.value = value;
+            return copied;
+        }
     }
 }

com.unity.shadergraph/Editor/Data/Graphs/MatrixShaderProperty.cs

         public override PreviewProperty GetPreviewMaterialProperty()
         {
             return default(PreviewProperty);
-        }        
+        }
     }
 }

com.unity.shadergraph/Editor/Data/Graphs/SamplerStateShaderProperty.cs

-using System;
+using System;
 using UnityEditor.Graphing;
 using UnityEngine;
 
         public override INode ToConcreteNode()
         {
             return new SamplerStateNode();
+        }
+
+        public override IShaderProperty Copy()
+        {
+            var copied = new SamplerStateShaderProperty();
+            copied.displayName = displayName;
+            copied.value = value;
+            return copied;
         }
     }
 }

com.unity.shadergraph/Editor/Data/Graphs/TextureShaderProperty.cs

-using System;
+using System;
 using System.Text;
 using UnityEditor.Graphing;
 using UnityEngine;
         public override INode ToConcreteNode()
         {
             return new Texture2DAssetNode { texture = value.texture };
+        }
+
+        public override IShaderProperty Copy()
+        {
+            var copied = new TextureShaderProperty();
+            copied.displayName = displayName;
+            copied.value = value;
+            return copied;
         }
     }
 }

com.unity.shadergraph/Editor/Data/Graphs/Vector1ShaderProperty.cs

                     return node;
             }
         }
+
+        public override IShaderProperty Copy()
+        {
+            var copied = new Vector1ShaderProperty();
+            copied.displayName = displayName;
+            copied.value = value;
+            return copied;
+        }
     }
 }

com.unity.shadergraph/Editor/Data/Graphs/Vector2ShaderProperty.cs

             node.FindInputSlot<Vector1MaterialSlot>(Vector2Node.InputSlotYId).value = value.y;
             return node;
         }
+
+        public override IShaderProperty Copy()
+        {
+            var copied = new Vector2ShaderProperty();
+            copied.displayName = displayName;
+            copied.value = value;
+            return copied;
+        }
     }
 }

com.unity.shadergraph/Editor/Data/Graphs/Vector3ShaderProperty.cs

             node.FindInputSlot<Vector1MaterialSlot>(Vector3Node.InputSlotZId).value = value.z;
             return node;
         }
+
+        public override IShaderProperty Copy()
+        {
+            var copied = new Vector3ShaderProperty();
+            copied.displayName = displayName;
+            copied.value = value;
+            return copied;
+        }
     }
 }

com.unity.shadergraph/Editor/Data/Graphs/Vector4ShaderProperty.cs

             node.FindInputSlot<Vector1MaterialSlot>(Vector4Node.InputSlotWId).value = value.w;
             return node;
         }
+
+        public override IShaderProperty Copy()
+        {
+            var copied = new Vector4ShaderProperty();
+            copied.displayName = displayName;
+            copied.value = value;
+            return copied;
+        }
     }
 }

com.unity.shadergraph/Editor/Data/MasterNodes/ISubShader.cs

 using System;
+using UnityEditor.Graphing;
+using UnityEngine.Experimental.UIElements;
-namespace UnityEditor.ShaderGraph {
+namespace UnityEditor.ShaderGraph
+{
-}
+}

com.unity.shadergraph/Editor/Data/MasterNodes/PBRMasterNode.cs

 using System.Linq;
 using System.Collections.Generic;
 using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing;
+using UnityEngine.Experimental.UIElements;
 
 namespace UnityEditor.ShaderGraph
 {
         }
 
         [SerializeField]
-        private Model m_Model = Model.Metallic;
+        Model m_Model = Model.Metallic;
-        [EnumControl("Workflow")]
         public Model model
         {
             get { return m_Model; }
         }
 
         [SerializeField]
-        private SurfaceType m_SurfaceType;
+        SurfaceType m_SurfaceType;
-        [EnumControl("Surface")]
         public SurfaceType surfaceType
         {
             get { return m_SurfaceType; }
 
                 m_SurfaceType = value;
                 Dirty(ModificationScope.Graph);
+
-        private AlphaMode m_AlphaMode;
+        AlphaMode m_AlphaMode;
-        [EnumControl("Blend")]
         public AlphaMode alphaMode
         {
             get { return m_AlphaMode; }
 
                 m_AlphaMode = value;
                 Dirty(ModificationScope.Graph);
+
-        private bool m_TwoSided;
+        bool m_TwoSided;
-        [ToggleControl("Two Sided")]
-        public Toggle twoSided
+        public ToggleData twoSided
-            get { return new Toggle(m_TwoSided); }
+            get { return new ToggleData(m_TwoSided); }
             set
             {
                 if (m_TwoSided == value.isOn)
             List<ISlot> slots = new List<ISlot>();
             GetSlots(slots);
             return slots.OfType<IMayRequireNormal>().Aggregate(NeededCoordinateSpace.None, (mask, node) => mask | node.RequiresNormal());
+        }
+
+        protected override VisualElement CreateCommonSettingsElement()
+        {
+            return new PBRSettingsView(this);
         }
     }
 }

com.unity.shadergraph/Editor/Data/MasterNodes/UnlitMasterNode.cs

 using System;
 using System.Linq;
 using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing;
+using UnityEngine.Experimental.UIElements;
 
 namespace UnityEditor.ShaderGraph
 {
         public const int AlphaSlotId = 7;
         public const int AlphaThresholdSlotId = 8;
 
-       
-        private SurfaceType m_SurfaceType;
+        SurfaceType m_SurfaceType;
-        [EnumControl("Surface")]
         public SurfaceType surfaceType
         {
             get { return m_SurfaceType; }
         }
 
         [SerializeField]
-        private AlphaMode m_AlphaMode;
+        AlphaMode m_AlphaMode;
-        [EnumControl("Blend")]
         public AlphaMode alphaMode
         {
             get { return m_AlphaMode; }
         }
 
         [SerializeField]
-        private bool m_TwoSided;
+        bool m_TwoSided;
-        [ToggleControl("Two Sided")]
-        public Toggle twoSided
+        public ToggleData twoSided
-            get { return new Toggle(m_TwoSided); }
+            get { return new ToggleData(m_TwoSided); }
             set
             {
                 if (m_TwoSided == value.isOn)
                 AlphaSlotId,
                 AlphaThresholdSlotId
             });
+        }
+
+        protected override VisualElement CreateCommonSettingsElement()
+        {
+            return new UnlitSettingsView(this);
         }
     }
 }

com.unity.shadergraph/Editor/Data/Nodes/Artistic/Adjustment/InvertColorsNode.cs

         private bool m_RedChannel;
 
         [ToggleControl("Red")]
-        public Toggle redChannel
+        public ToggleData redChannel
-            get { return new Toggle(m_RedChannel, channelCount > 0); }
+            get { return new ToggleData(m_RedChannel, channelCount > 0); }
             set
             {
                 if (m_RedChannel == value.isOn)
         private bool m_GreenChannel;
 
         [ToggleControl("Green")]
-        public Toggle greenChannel
+        public ToggleData greenChannel
-            get { return new Toggle(m_GreenChannel, channelCount > 1); }
+            get { return new ToggleData(m_GreenChannel, channelCount > 1); }
             set
             {
                 if (m_GreenChannel == value.isOn)
         private bool m_BlueChannel;
 
         [ToggleControl("Blue")]
-        public Toggle blueChannel
+        public ToggleData blueChannel
-            get { return new Toggle(m_BlueChannel, channelCount > 2); }
+            get { return new ToggleData(m_BlueChannel, channelCount > 2); }
             set
             {
                 if (m_BlueChannel == value.isOn)
         private bool m_AlphaChannel;
 
         [ToggleControl("Alpha")]
-        public Toggle alphaChannel
+        public ToggleData alphaChannel
-            get { return new Toggle(m_AlphaChannel, channelCount > 3); }
+            get { return new ToggleData(m_AlphaChannel, channelCount > 3); }
             set
             {
                 if (m_AlphaChannel == value.isOn)

com.unity.shadergraph/Editor/Data/Nodes/Channel/FlipNode.cs

         private bool m_RedChannel;
 
         [ToggleControl("Red")]
-        public Toggle redChannel
+        public ToggleData redChannel
-            get { return new Toggle(m_RedChannel, channelCount > 0); }
+            get { return new ToggleData(m_RedChannel, channelCount > 0); }
             set
             {
                 if (m_RedChannel == value.isOn)
         private bool m_GreenChannel;
 
         [ToggleControl("Green")]
-        public Toggle greenChannel
+        public ToggleData greenChannel
-            get { return new Toggle(m_GreenChannel, channelCount > 1); }
+            get { return new ToggleData(m_GreenChannel, channelCount > 1); }
             set
             {
                 if (m_GreenChannel == value.isOn)
         private bool m_BlueChannel;
 
         [ToggleControl("Blue")]
-        public Toggle blueChannel
+        public ToggleData blueChannel
-            get { return new Toggle(m_BlueChannel, channelCount > 2); }
+            get { return new ToggleData(m_BlueChannel, channelCount > 2); }
             set
             {
                 if (m_BlueChannel == value.isOn)
         private bool m_AlphaChannel;
 
         [ToggleControl("Alpha")]
-        public Toggle alphaChannel
+        public ToggleData alphaChannel
-            get { return new Toggle(m_AlphaChannel, channelCount > 3); }
+            get { return new ToggleData(m_AlphaChannel, channelCount > 3); }
             set
             {
                 if (m_AlphaChannel == value.isOn)

com.unity.shadergraph/Editor/Data/Nodes/IMasterNode.cs

 using System.Collections.Generic;
+using UnityEditor.Graphing;
-    public interface IMasterNode
+    public interface IMasterNode : INode
     {
         string GetShader(GenerationMode mode, string name, out List<PropertyCollector.TextureInfo> configuredTextures);
         bool IsPipelineCompatible(IRenderPipeline renderPipeline);

com.unity.shadergraph/Editor/Data/Nodes/Input/Basic/BooleanNode.cs

         }
 
         [ToggleControl("")]
-        public Toggle value
+        public ToggleData value
-            get { return new Toggle(m_Value); }
+            get { return new ToggleData(m_Value); }
             set
             {
                 if (m_Value == value.isOn)

com.unity.shadergraph/Editor/Data/Nodes/Input/Basic/Vector1Node.cs

 
         public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
         {
-            if (generationMode.IsPreview())
-                return;
-
-            visitor.AddShaderChunk(precision + " " + GetVariableNameForNode() + " = " + inputValue + ";", false);
-        }
-
-        public override string GetVariableNameForSlot(int slotId)
-        {
-            return GetVariableNameForNode();
+            visitor.AddShaderChunk(precision + " " + GetVariableNameForSlot(OutputSlotId) + " = " + inputValue + ";", false);
         }
 
         public IShaderProperty AsShaderProperty()

com.unity.shadergraph/Editor/Data/Nodes/MasterNode.cs

 using UnityEditor.Graphing.Util;
 using UnityEngine;
 using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.UIElements;
-    public abstract class MasterNode<T> : AbstractMaterialNode, IMasterNode where T : class, ISubShader
+    public abstract class MasterNode<T> : AbstractMaterialNode, IMasterNode, IHasSettings
+        where T : class, ISubShader
     {
         [NonSerialized]
         List<T> m_SubShaders = new List<T>();
         public override void OnAfterDeserialize()
         {
             m_SubShaders = SerializationHelper.Deserialize<T>(m_SerializableSubShaders, GraphUtil.GetLegacyTypeRemapping());
+            m_SubShaders.RemoveAll(x => x == null);
             m_SerializableSubShaders = null;
             base.OnAfterDeserialize();
 
                     }
                 }
             }
+        }
+
+        public VisualElement CreateSettingsElement()
+        {
+            var container = new VisualElement();
+            var commonSettingsElement = CreateCommonSettingsElement();
+            if (commonSettingsElement != null)
+                container.Add(commonSettingsElement);
+
+            return container;
+        }
+
+        protected virtual VisualElement CreateCommonSettingsElement()
+        {
+            return null;
         }
     }
 }

com.unity.shadergraph/Editor/Data/Nodes/UV/FlipbookNode.cs

         private bool m_InvertX = false;
 
         [ToggleControl("Invert X")]
-        public Toggle invertX
+        public ToggleData invertX
-            get { return new Toggle(m_InvertX); }
+            get { return new ToggleData(m_InvertX); }
             set
             {
                 if (m_InvertX == value.isOn)
         private bool m_InvertY = true;
 
         [ToggleControl("Invert Y")]
-        public Toggle invertY
+        public ToggleData invertY
-            get { return new Toggle(m_InvertY); }
+            get { return new ToggleData(m_InvertY); }
             set
             {
                 if (m_InvertY == value.isOn)

com.unity.shadergraph/Editor/Data/Util/GraphUtil.cs

-using System;
+using System;
+using System.Text.RegularExpressions;
 using UnityEditor.Graphing;
 using UnityEditor.Graphing.Util;
 using UnityEngine;
             }
 
             return s_LegacyTypeRemapping;
+        }
+
+        /// <summary>
+        /// Sanitizes a supplied string such that it does not collide
+        /// with any other name in a collection.
+        /// </summary>
+        /// <param name="existingNames">
+        /// A collection of names that the new name should not collide with.
+        /// </param>
+        /// <param name="duplicateFormat">
+        /// The format applied to the name if a duplicate exists.
+        /// This must be a format string that contains `{0}` and `{1}`
+        /// once each. An example could be `{0} ({1})`, which will append ` (n)`
+        /// to the name for the n`th duplicate.
+        /// </param>
+        /// <param name="name">
+        /// The name to be sanitized.
+        /// </param>
+        /// <returns>
+        /// A name that is distinct form any name in `existingNames`.
+        /// </returns>
+        internal static string SanitizeName(IEnumerable<string> existingNames, string duplicateFormat, string name)
+        {
+            if (!existingNames.Contains(name))
+                return name;
+
+            string escapedDuplicateFormat = Regex.Escape(duplicateFormat);
+
+            // Escaped format will escape string interpolation, so the escape caracters must be removed for these.
+            escapedDuplicateFormat = escapedDuplicateFormat.Replace(@"\{0}", @"{0}");
+            escapedDuplicateFormat = escapedDuplicateFormat.Replace(@"\{1}", @"{1}");
+
+            var baseRegex = new Regex(string.Format(escapedDuplicateFormat, @"^(.*)", @"(\d+)"));
+
+            var baseMatch = baseRegex.Match(name);
+            if (baseMatch.Success)
+                name = baseMatch.Groups[1].Value;
+
+            string baseNameExpression= string.Format(@"^{0}", Regex.Escape(name));
+            var regex = new Regex(string.Format(escapedDuplicateFormat, baseNameExpression, @"(\d+)") + "$");
+
+            var existingDuplicateNumbers = existingNames.Select(existingName => regex.Match(existingName)).Where(m => m.Success).Select(m => int.Parse(m.Groups[1].Value)).Where(n => n > 0).Distinct().ToList();
+
+            var duplicateNumber = 1;
+            existingDuplicateNumbers.Sort();
+            if (existingDuplicateNumbers.Any() && existingDuplicateNumbers.First() == 1)
+            {
+                duplicateNumber = existingDuplicateNumbers.Last() + 1;
+                for (var i = 1; i < existingDuplicateNumbers.Count; i++)
+                {
+                    if (existingDuplicateNumbers[i - 1] != existingDuplicateNumbers[i] - 1)
+                    {
+                        duplicateNumber = existingDuplicateNumbers[i - 1] + 1;
+                        break;
+                    }
+                }
+            }
+
+            return string.Format(duplicateFormat, name, duplicateNumber);
         }
     }
 }

com.unity.shadergraph/Editor/Drawing/Blackboard/BlackboardFieldPropertyView.cs

 using System;
+using System.Linq;
+using UnityEditor.Graphing.Util;
+using UnityEngine.Experimental.UIElements.StyleSheets;
+using Toggle = UnityEngine.Experimental.UIElements.Toggle;
 
 namespace UnityEditor.ShaderGraph.Drawing
 {
+
+        IShaderProperty m_Property;
+        Toggle m_ExposedToogle;
+        TextField m_ReferenceNameField;
+
+        static Type s_ContextualMenuManipulator = AppDomain.CurrentDomain.GetAssemblies().SelectMany(x => x.GetTypesOrNothing()).FirstOrDefault(t => t.FullName == "UnityEngine.Experimental.UIElements.ContextualMenuManipulator");
+
+        IManipulator m_ResetReferenceMenu;
+            AddStyleSheetPath("Styles/ShaderGraphBlackboard");
+            m_Property = property;
+
+            m_ExposedToogle = new Toggle(() =>
+            {
+                property.generatePropertyBlock = m_ExposedToogle.value;
+                DirtyNodes(ModificationScope.Graph);
+            });
+            m_ExposedToogle.value = property.generatePropertyBlock;
+            AddRow("Exposed", m_ExposedToogle);
+
+            m_ReferenceNameField = new TextField(512, false, false, ' ');
+            m_ReferenceNameField.AddStyleSheetPath("Styles/PropertyNameReferenceField");
+            AddRow("Reference", m_ReferenceNameField);
+            m_ReferenceNameField.value = property.referenceName;
+            m_ReferenceNameField.isDelayed = true;
+            m_ReferenceNameField.OnValueChanged(newName =>
+            {
+                string newReferenceName = m_Graph.SanitizePropertyReferenceName(newName.newValue, property.guid);
+                property.overrideReferenceName = newReferenceName;
+                m_ReferenceNameField.value = property.referenceName;
+
+                if (string.IsNullOrEmpty(property.overrideReferenceName))
+                    m_ReferenceNameField.RemoveFromClassList("modified");
+                else
+                    m_ReferenceNameField.AddToClassList("modified");
+
+                DirtyNodes(ModificationScope.Graph);
+                UpdateReferenceNameResetMenu();
+            });
+
+            if (!string.IsNullOrEmpty(property.overrideReferenceName))
+                m_ReferenceNameField.AddToClassList("modified");
+
             if (property is Vector1ShaderProperty)
             {
                 VisualElement floatRow = new VisualElement();
 //            AddRow("Default", new TextField());
 //            AddRow("Tooltip", new TextField());
 
+
+
+            UpdateReferenceNameResetMenu();
+        }
+
+        void UpdateReferenceNameResetMenu()
+        {
+            if (string.IsNullOrEmpty(m_Property.overrideReferenceName))
+            {
+                this.RemoveManipulator(m_ResetReferenceMenu);
+                m_ResetReferenceMenu = null;
+            }
+            else
+            {
+                m_ResetReferenceMenu = (IManipulator)Activator.CreateInstance(s_ContextualMenuManipulator, (Action<ContextualMenuPopulateEvent>)BuildContextualMenu);
+                this.AddManipulator(m_ResetReferenceMenu);
+            }
+        }
+
+        void BuildContextualMenu(ContextualMenuPopulateEvent evt)
+        {
+            evt.menu.AppendAction("Reset reference", e =>
+            {
+                m_Property.overrideReferenceName = null;
+                m_ReferenceNameField.value = m_Property.referenceName;
+                m_ReferenceNameField.RemoveFromClassList("modified");
+                DirtyNodes(ModificationScope.Graph);
+            }, ContextualMenu.MenuAction.AlwaysEnabled);
         }
 
         VisualElement AddRow(string labelText, VisualElement control)
             }
         }
 
-        void DirtyNodes()
+        void DirtyNodes(ModificationScope modificationScope = ModificationScope.Node)
-                node.Dirty(ModificationScope.Node);
+                node.Dirty(modificationScope);
         }
     }
 }

com.unity.shadergraph/Editor/Drawing/Blackboard/BlackboardProvider.cs

-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using UnityEditor.Experimental.UIElements.GraphView;

com.unity.shadergraph/Editor/Drawing/Controls/ToggleControl.cs

 namespace UnityEditor.ShaderGraph.Drawing.Controls
 {
     [Serializable]
-    public struct Toggle
+    public struct ToggleData
-        public Toggle(bool on, bool enabled)
+        public ToggleData(bool on, bool enabled)
-        public Toggle(bool on)
+        public ToggleData(bool on)
         {
             isOn = on;
             isEnabled = true;
             m_PropertyInfo = propertyInfo;
             AddStyleSheetPath("Styles/Controls/ToggleControlView");
 
-            if (propertyInfo.PropertyType != typeof(Toggle))
+            if (propertyInfo.PropertyType != typeof(ToggleData))
-            var value = (Toggle)m_PropertyInfo.GetValue(m_Node, null);
+            var value = (ToggleData)m_PropertyInfo.GetValue(m_Node, null);
             var panel = new VisualElement { name = "togglePanel" };
             if (!string.IsNullOrEmpty(label))
                 panel.Add(new Label(label));
 
         public void OnNodeModified(ModificationScope scope)
         {
-            var value = (Toggle)m_PropertyInfo.GetValue(m_Node, null);
+            var value = (ToggleData)m_PropertyInfo.GetValue(m_Node, null);
             m_Toggle.SetEnabled(value.isEnabled);
 
             if (scope == ModificationScope.Graph)
         void OnChangeToggle()
         {
             m_Node.owner.owner.RegisterCompleteObjectUndo("Toggle Change");
-            var value = (Toggle)m_PropertyInfo.GetValue(m_Node, null);
+            var value = (ToggleData)m_PropertyInfo.GetValue(m_Node, null);
             value.isOn = !value.isOn;
             m_PropertyInfo.SetValue(m_Node, value, null);
             this.MarkDirtyRepaint();

com.unity.shadergraph/Editor/Drawing/MaterialGraphEditWindow.cs

 #if UNITY_2018_1
 using GeometryChangedEvent = UnityEngine.Experimental.UIElements.PostLayoutEvent;
 #else
+using UnityEditor.Experimental.UIElements.GraphView;
 using GeometryChangedEvent = UnityEngine.Experimental.UIElements.GeometryChangedEvent;
 #endif
 
             var middle = bounds.center;
             bounds.center = Vector2.zero;
 
+            // Collect the property nodes and get the corresponding properties
+            var propertyNodeGuids = graphView.selection.OfType<MaterialNodeView>().Where(x => (x.node is PropertyNode)).Select(x => ((PropertyNode)x.node).propertyGuid);
+            var metaProperties = graphView.graph.properties.Where(x => propertyNodeGuids.Contains(x.guid));
+
-                    graphView.selection.OfType<Edge>().Select(x => x.userData as IEdge));
+                    graphView.selection.OfType<Edge>().Select(x => x.userData as IEdge),
+                    graphView.selection.OfType<BlackboardField>().Select(x => x.userData as IShaderProperty),
+                    metaProperties);
 
             var deserialized = CopyPasteGraph.FromJson(JsonUtility.ToJson(copyPasteGraph, false));
             if (deserialized == null)

com.unity.shadergraph/Editor/Drawing/Views/MaterialGraphView.cs

 using UnityEditor.Graphing;
 using UnityEngine.Experimental.UIElements;
 using Edge = UnityEditor.Experimental.UIElements.GraphView.Edge;
+using Node = UnityEditor.Experimental.UIElements.GraphView.Node;
+#if !UNITY_2018_1
+using UnityEditor.Graphs;
+#endif
 
 namespace UnityEditor.ShaderGraph.Drawing
 {
             canPasteSerializedData = CanPasteSerializedDataImplementation;
             unserializeAndPaste = UnserializeAndPasteImplementation;
             deleteSelection = DeleteSelectionImplementation;
+        }
+
+        protected override bool canCopySelection
+        {
+            get { return selection.OfType<Node>().Any() || selection.OfType<GroupNode>().Any() || selection.OfType<BlackboardField>().Any(); }
         }
 
         public MaterialGraphView(AbstractMaterialGraph graph) : this()
             onConvertToSubgraphClick();
         }
 
-        public delegate void OnSelectionChanged(IEnumerable<INode> nodes);
-
-        public OnSelectionChanged onSelectionChanged;
-
-        void SelectionChanged()
+        string SerializeGraphElementsImplementation(IEnumerable<GraphElement> elements)
-            var selectedNodes = selection.OfType<MaterialNodeView>().Where(x => x.userData is INode);
-            if (onSelectionChanged != null)
-                onSelectionChanged(selectedNodes.Select(x => x.userData as INode));
-        }
+            var nodes = elements.OfType<MaterialNodeView>().Select(x => (INode)x.node);
+            var edges = elements.OfType<Edge>().Select(x => x.userData).OfType<IEdge>();
+            var properties = selection.OfType<BlackboardField>().Select(x => x.userData as IShaderProperty);
-        public override void AddToSelection(ISelectable selectable)
-        {
-            base.AddToSelection(selectable);
-            SelectionChanged();
-        }
+            // Collect the property nodes and get the corresponding properties
+            var propertyNodeGuids = nodes.OfType<PropertyNode>().Select(x => x.propertyGuid);
+            var metaProperties = this.graph.properties.Where(x => propertyNodeGuids.Contains(x.guid));
-        public override void RemoveFromSelection(ISelectable selectable)
-        {
-            base.RemoveFromSelection(selectable);
-            SelectionChanged();
-        }
-
-        public override void ClearSelection()
-        {
-            base.ClearSelection();
-            SelectionChanged();
-        }
-
-        string SerializeGraphElementsImplementation(IEnumerable<GraphElement> elements)
-        {
-            var graph = new CopyPasteGraph(elements.OfType<MaterialNodeView>().Select(x => (INode)x.node), elements.OfType<Edge>().Select(x => x.userData).OfType<IEdge>());
+            var graph = new CopyPasteGraph(nodes, edges, properties, metaProperties);
             return JsonUtility.ToJson(graph, true);
         }
 
         {
             if (copyGraph == null)
                 return;
+
+            // Make new properties from the copied graph
+            foreach (IShaderProperty property in copyGraph.properties)
+            {
+                string propertyName = graphView.graph.SanitizePropertyName(property.displayName);
+                IShaderProperty copiedProperty = property.Copy();
+                copiedProperty.displayName = propertyName;
+                graphView.graph.AddShaderProperty(copiedProperty);
+
+                // Update the property nodes that depends on the copied node
+                var dependentPropertyNodes = copyGraph.GetNodes<PropertyNode>().Where(x => x.propertyGuid == property.guid);
+                foreach (var node in dependentPropertyNodes)
+                {
+                    node.owner = graphView.graph;
+                    node.propertyGuid = copiedProperty.guid;
+                }
+            }
 
             using (var remappedNodesDisposable = ListPool<INode>.GetDisposable())
                 using (var remappedEdgesDisposable = ListPool<IEdge>.GetDisposable())

com.unity.shadergraph/Editor/Drawing/Views/MaterialNodeView.cs

 using UnityEditor.ShaderGraph.Drawing.Controls;
 using UnityEngine.Experimental.Rendering;
 using UnityEngine.Experimental.UIElements.StyleEnums;
+using UnityEngine.Experimental.UIElements.StyleSheets;
 using Node = UnityEditor.Experimental.UIElements.GraphView.Node;
 #if UNITY_2018_1
 using GeometryChangedEvent = UnityEngine.Experimental.UIElements.PostLayoutEvent;
         VisualElement m_ControlsDivider;
         IEdgeConnectorListener m_ConnectorListener;
         VisualElement m_PortInputContainer;
+        VisualElement m_SettingsContainer;
+        bool m_ShowSettings = false;
+        VisualElement m_SettingsButton;
+        VisualElement m_Settings;
+        VisualElement m_NodeSettingsView;
+
 
 
         public void Initialize(AbstractMaterialNode inNode, PreviewManager previewManager, IEdgeConnectorListener connectorListener)
 
             SetPosition(new Rect(node.drawState.position.x, node.drawState.position.y, 0, 0));
 
-            /*if (node is PreviewNode)
-            {
-                var resizeHandle = new Label { name = "resize", text = "" };
-                resizeHandle.AddManipulator(new Draggable(OnResize));
-                Add(resizeHandle);
-                UpdateSize();
-            }*/
-
             if (node is SubGraphNode)
             {
                 RegisterCallback<MouseDownEvent>(OnSubGraphDoubleClick);
             }
 
             m_PortInputContainer.SendToBack();
-            if (node.hasPreview)
-                m_PreviewFiller.BringToFront();
+
+            // Remove this after updated to the correct API call has landed in trunk. ------------
+            VisualElement m_TitleContainer;
+            VisualElement m_ButtonContainer;
+            m_TitleContainer = this.Q("title");
+            // -----------------------------------------------------------------------------------
+
+            var settings = node as IHasSettings;
+            if (settings != null)
+            {
+                m_NodeSettingsView = new NodeSettingsView();
+                m_NodeSettingsView.visible = false;
+
+                Add(m_NodeSettingsView);
+
+                m_SettingsButton = new VisualElement {name = "settings-button"};
+                m_SettingsButton.Add(new VisualElement { name = "icon" });
+
+                m_Settings = settings.CreateSettingsElement();
+
+                m_SettingsButton.AddManipulator(new Clickable(() =>
+                {
+                    UpdateSettingsExpandedState();
+                }));
+
+                // Remove this after updated to the correct API call has landed in trunk. ------------
+                m_ButtonContainer = new VisualElement{ name = "button-container" };
+                m_ButtonContainer.style.flexDirection = StyleValue<FlexDirection>.Create(FlexDirection.Row);
+                m_ButtonContainer.Add(m_SettingsButton);
+                m_ButtonContainer.Add(m_CollapseButton);
+                m_TitleContainer.Add(m_ButtonContainer);
+                // -----------------------------------------------------------------------------------
+                //titleButtonContainer.Add(m_SettingsButton);
+                //titleButtonContainer.Add(m_CollapseButton);
+
+                RegisterCallback<GeometryChangedEvent>(OnGeometryChanged);
+            }
+        }
+
+        void OnGeometryChanged(GeometryChangedEvent evt)
+        {
+            // style.positionTop and style.positionLeft are in relation to the parent,
+            // so we translate the layout of the settings button to be in the coordinate
+            // space of the settings view's parent.
+
+            var settingsButtonLayout = m_SettingsButton.ChangeCoordinatesTo(m_NodeSettingsView.parent, m_SettingsButton.layout);
+            m_NodeSettingsView.style.positionTop = settingsButtonLayout.yMax - 18f;
+            m_NodeSettingsView.style.positionLeft = settingsButtonLayout.xMin - 16f;
         }
 
         void OnSubGraphDoubleClick(MouseDownEvent evt)
 
                 RefreshExpandedState(); //This should not be needed. GraphView needs to improve the extension api here
                 UpdatePortInputVisibilities();
-                if (node.hasPreview)
-                    m_PreviewFiller.BringToFront();
             }
         }
 
             {
                 var graph = (AbstractMaterialGraph)node.owner;
                 GUIUtility.systemCopyBuffer = graph.GetShader(node, GenerationMode.ForReals, node.name).shader;
+            }
+        }
+
+        void UpdateSettingsExpandedState()
+        {
+            m_ShowSettings = !m_ShowSettings;
+            if (m_ShowSettings)
+            {
+                m_NodeSettingsView.Add(m_Settings);
+                m_NodeSettingsView.visible = true;
+
+                m_SettingsButton.AddToClassList("clicked");
+            }
+            else
+            {
+                m_Settings.RemoveFromHierarchy();
+
+                m_NodeSettingsView.visible = false;
+                m_SettingsButton.RemoveFromClassList("clicked");
             }
         }
 
 
             foreach (var portInputView in m_PortInputContainer.OfType<PortInputView>())
                 portInputView.UpdateSlotType();
+
+            foreach (var control in m_ControlItems)
+            {
+                var listener = control as INodeModificationListener;
+                if (listener != null)
+                    listener.OnNodeModified(ModificationScope.Graph);
+            }
         }
 
         void OnResize(Vector2 deltaSize)

com.unity.shadergraph/Editor/Resources/Styles/Blackboard.uss

 
 .sgblackboardField > .mainContainer > #contentItem > #pill > #textLabel {
     font-size: 11;
-}
-
-.sgblackboardFieldPropertyView > .rowView {
-    flex-direction: row;
-    padding-left: 10;
-    padding-right: 2;
-    padding-top: 2;
-    padding-bottom: 2;
-}
-
-.sgblackboardFieldPropertyView > .rowView > .rowViewLabel {
-    min-width: 50;
-    font-size: 11;
-}
-
-.sgblackboardFieldPropertyView > .rowView > .rowViewControl {
-    flex: 1;
-}
+}

com.unity.shadergraph/Editor/Resources/Styles/MaterialNodeView.uss

 }
 
 MaterialNodeView > #settings-container {
-	position-type : absolute;
-	width : 200;
-	background-color : rgb(245, 155, 225);
-	position-left : 200;
+	background-color : rgb(63, 63, 63);
-MaterialNodeView > #node-border > #title > #button-container{
-	flex-direction: row;
-	justify-content : space-between;
+#settings-button {
+    width: 16;
+    align-self: center;
+    justify-content: center;
+    padding-left: 8;
-MaterialNodeView  > #node-border > #title > #button-container > #settings-button{
-	align-self : center;
-	width : 16;
+#settings-button > #icon {
+    width : 12;
+    height : 12;
+    align-self: center;
+    visibility: hidden;
+    background-image : resource("Icons/SettingsIcons");
-MaterialNodeView  > #node-border > #title > #button-container > #settings-button:hover{
-	background-color: #2B2B2B;
+.node:hover #settings-button > #icon {
+    visibility: visible;
+#settings-button:hover > #icon {
+    align-self: center;
+    background-color: #2B2B2B;
+    background-image : resource("Icons/SettingsIcons_hover");
+}
-MaterialNodeView  > #node-border > #title > #button-container > #settings-button.clicked{
-	background-color: #2B2B2B;
+#settings-button.clicked > #icon{
+    background-color: #2B2B2B;
+    background-image : resource("Icons/SettingsIcons_hover");
+    visibility: visible;
+}
+
+.node.collapsed > #node-border > #title > #button-container > #collapse-button > #icon {
+    background-image: resource("GraphView/Nodes/NodeChevronLeft.png");
-MaterialNodeView  > #node-border > #title > #button-container > #settings-button > #icon{
-	align-self : center;
-	background-image : resource("Icons/settingsbutton");
-	width : 16;
-	height : 16;
-}
+.node.expanded > #node-border > #title > #button-container > #collapse-button > #icon {
+    background-image : resource("GraphView/Nodes/NodeChevronDown.png");
+}

com.unity.shadergraph/Editor/Util/CopyPasteGraph.cs

         [NonSerialized]
         HashSet<INode> m_Nodes = new HashSet<INode>();
 
+        [NonSerialized]
+        HashSet<IShaderProperty> m_Properties = new HashSet<IShaderProperty>();
+
+        // The meta properties are properties that are not copied into the tatget graph
+        // but sent along to allow property nodes to still hvae the data from the original
+        // property present.
+        [NonSerialized]
+        HashSet<IShaderProperty> m_MetaProperties = new HashSet<IShaderProperty>();
+
+
+        [SerializeField]
+        List<SerializationHelper.JSONSerializedElement> m_SerilaizeableProperties = new List<SerializationHelper.JSONSerializedElement>();
+
+        [SerializeField]
+        List<SerializationHelper.JSONSerializedElement> m_SerializableMetaProperties = new List<SerializationHelper.JSONSerializedElement>();
-        public CopyPasteGraph(IEnumerable<INode> nodes, IEnumerable<IEdge> edges)
+        public CopyPasteGraph(IEnumerable<INode> nodes, IEnumerable<IEdge> edges, IEnumerable<IShaderProperty> properties, IEnumerable<IShaderProperty> metaProperties)
         {
             foreach (var node in nodes)
             {
 
             foreach (var edge in edges)
                 AddEdge(edge);
+
+            foreach (var property in properties)
+                AddProperty(property);
+
+            foreach (var metaProperty in metaProperties)
+                AddMetaProperty(metaProperty);
         }
 
         public void AddNode(INode node)
             m_Edges.Add(edge);
         }
 
+        public void AddProperty(IShaderProperty property)
+        {
+            m_Properties.Add(property);
+        }
+
+        public void AddMetaProperty(IShaderProperty metaProperty)
+        {
+            m_MetaProperties.Add(metaProperty);
+        }
+
         public IEnumerable<T> GetNodes<T>() where T : INode
         {
             return m_Nodes.OfType<T>();
             get { return m_Edges; }
         }
 
+        public IEnumerable<IShaderProperty> properties
+        {
+            get { return m_Properties; }
+        }
+
+        public IEnumerable<IShaderProperty> metaProperties
+        {
+            get { return m_MetaProperties; }
+        }
+
+            m_SerilaizeableProperties = SerializationHelper.Serialize<IShaderProperty>(m_Properties);
+            m_SerializableMetaProperties = SerializationHelper.Serialize<IShaderProperty>(m_MetaProperties);
         }
 
         public void OnAfterDeserialize()
             foreach (var edge in edges)
                 m_Edges.Add(edge);
             m_SerializableEdges = null;
+
+            var properties = SerializationHelper.Deserialize<IShaderProperty>(m_SerilaizeableProperties, GraphUtil.GetLegacyTypeRemapping());
+            m_Properties.Clear();
+            foreach (var property in properties)
+                m_Properties.Add(property);
+            m_SerilaizeableProperties = null;
+
+            var metaProperties = SerializationHelper.Deserialize<IShaderProperty>(m_SerializableMetaProperties, GraphUtil.GetLegacyTypeRemapping());
+            m_MetaProperties.Clear();
+            foreach (var metaProperty in metaProperties)
+            {
+                m_MetaProperties.Add(metaProperty);
+            }
+            m_SerializableMetaProperties = null;
         }
 
         internal static CopyPasteGraph FromJson(string copyBuffer)

com.unity.shadergraph/Editor/Util/UIUtilities.cs

 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using UnityEngine.Experimental.UIElements;
 
 namespace UnityEditor.Graphing.Util
 {
         public static IEnumerable<T> ToEnumerable<T>(this T item)
         {
             yield return item;
+        }
+
+        public static void Add<T>(this VisualElement visualElement, T elementToAdd, Action<T> action)
+            where T : VisualElement
+        {
+            visualElement.Add(elementToAdd);
+            action(elementToAdd);
         }
 
         public static IEnumerable<Type> GetTypesOrNothing(this Assembly assembly)

LICENSE.md

-Unity Companion License (“License”)
-Software Copyright © 2018 Unity Technologies ApS 
-
-Unity Technologies ApS (“Unity”) grants to you a worldwide, non-exclusive,
-no-charge, and royalty-free copyright license to reproduce, prepare derivative
-works of, publicly display, publicly perform, sublicense, and distribute the
-software that is made available under this License (“Software”), subject to the
-following terms and conditions: 
-
-1. Unity Companion Use Only. Exercise of the license granted herein is limited
-to exercise for the creation, use, and/or distribution of applications,
-software, or other content pursuant to a valid Unity content authoring and
-rendering engine software license (“Engine License”). That means while use of
-the Software is not limited to use in the software licensed under the Engine
-License, the Software may not be used for any purpose other than the creation,
-use, and/or distribution of Engine License-dependent applications, software, or
-other content. No other exercise of the license granted herein is permitted,
-and in no event may the Software be used for competitive analysis or to develop
-a competing product or service.
-
-2. No Modification of Engine License. Neither this License nor any exercise of
-the license granted herein modifies the Engine License in any way.
-
-3. Ownership & Grant Back to You. 
-
-3.1 You own your content. In this License, “derivative works” means derivatives
-of the Software itself--works derived only from the Software by you under this
-License (for example, modifying the code of the Software itself to improve its
-efficacy); “derivative works” of the Software do not include, for example,
-games, apps, or content that you create using the Software. You keep all right,
-title, and interest to your own content.
-
-3.2 Unity owns its content. While you keep all right, title, and interest to
-your own content per the above, as between Unity and you, Unity will own all
-right, title, and interest to all intellectual property rights (including
-patent, trademark, and copyright) in the Software and derivative works of the
-Software, and you hereby assign and agree to assign all such rights in those
-derivative works to Unity. 
-
-3.3 You have a license to those derivative works. Subject to this License,
-Unity grants to you the same worldwide, non-exclusive, no-charge, and
-royalty-free copyright license to derivative works of the Software you create
-as is granted to you for the Software under this License.
-
-4. Trademarks. You are not granted any right or license under this License to
-use any trademarks, service marks, trade names, products names, or branding of
-Unity or its affiliates (“Trademarks”). Descriptive uses of Trademarks are
-permitted; see, for example, Unity’s Branding Usage Guidelines at
-https://unity3d.com/public-relations/brand.
+Shader Graph copyright © 2018 Unity Technologies ApS
-5. Notices & Third-Party Rights. This License, including the copyright notice
-associated with the Software, must be provided in all substantial portions of
-the Software and derivative works thereof (or, if that is impracticable, in any
-other location where such notices are customarily placed). Further, if the
-Software is accompanied by a Unity “third-party notices” or similar file, you
-acknowledge and agree that software identified in that file is governed by
-those separate license terms.
+Licensed under the Unity Companion License for Unity-dependent projects--see [Unity Companion License](http://www.unity3d.com/legal/licenses/Unity_Companion_License). 
-6. DISCLAIMER, LIMITATION OF LIABILITY. THE SOFTWARE AND ANY DERIVATIVE WORKS
-THEREOF IS PROVIDED ON AN "AS IS" BASIS, AND IS PROVIDED WITHOUT WARRANTY OF
-ANY KIND, WHETHER EXPRESS OR IMPLIED, INCLUDING ANY WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND/OR NONINFRINGEMENT. IN
-NO EVENT SHALL ANY COPYRIGHT HOLDER OR AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES
-(WHETHER DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL,
-INCLUDING PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF USE, DATA, OR
-PROFITS, AND BUSINESS INTERRUPTION), OR OTHER LIABILITY WHATSOEVER, WHETHER IN
-AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM OR OUT OF, OR IN
-CONNECTION WITH, THE SOFTWARE OR ANY DERIVATIVE WORKS THEREOF OR THE USE OF OR
-OTHER DEALINGS IN SAME, EVEN WHERE ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-7. USE IS ACCEPTANCE and License Versions. Your receipt and use of the Software
-constitutes your acceptance of this License and its terms and conditions.
-Software released by Unity under this License may be modified or updated and
-the License with it; upon any such modification or update, you will comply with
-the terms of the updated License for any use of any of the Software under the
-updated License. 
-
-8. Use in Compliance with Law and Termination. Your exercise of the license
-granted herein will at all times be in compliance with applicable law and will
-not infringe any proprietary rights (including intellectual property rights);
-this License will terminate immediately on any breach by you of this License.
-
-9. Severability. If any provision of this License is held to be unenforceable
-or invalid, that provision will be enforced to the maximum extent possible and
-the other provisions will remain in full force and effect.
-
-10. Governing Law and Venue. This License is governed by and construed in
-accordance with the laws of Denmark, except for its conflict of laws rules; the
-United Nations Convention on Contracts for the International Sale of Goods will
-not apply. If you reside (or your principal place of business is) within the
-United States, you and Unity agree to submit to the personal and exclusive
-jurisdiction of and venue in the state and federal courts located in San
-Francisco County, California concerning any dispute arising out of this License
-(“Dispute”). If you reside (or your principal place of business is) outside the
-United States, you and Unity agree to submit to the personal and exclusive
-jurisdiction of and venue in the courts located in Copenhagen, Denmark
-concerning any Dispute. 
+Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.

CHANGELOG.md

+# Next version
+
+### Master node settings
+
+![](.data/menu_settings.png)
+
+The settings on master nodes now live in a small window that you can toggle on and off. The settings menu allows you to change various rendering settings for your shader.
+
+### Editable property names
+
+![](.data/editable_property_references.gif)
+
+The property reference names are now editable. It is also now possible to make the properties not exposed.
+
+### Bug fixes and minor changes
+
+- Fixed an issue where vector 1 node was not evaluating properly. ([#334](https://github.com/Unity-Technologies/ShaderGraph/issues/334) and [#337](https://github.com/Unity-Technologies/ShaderGraph/issues/337))
+- Properties can now be copied and pasted.
+- Pasting a property node into another graph will now convert it to a concrete node. ([#300](https://github.com/Unity-Technologies/ShaderGraph/issues/300))

CHANGELOG.md.meta

+fileFormatVersion: 2
+guid: 7a432963c0c501d489f74905a4c41a13
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

CONTRIBUTIONS.md

+# Contributions
+
+## If you are interested in contributing, here are some ground rules:
+* Talk to us before doing the work -- we love contributions, but we might already be working on the same thing, or we might have different opinions on how it should be implemented.
+
+## All contributions are subject to the [Unity Contribution Agreement(UCA)](https://unity3d.com/legal/licenses/Unity_Contribution_Agreement)
+By making a pull request, you are confirming agreement to the terms and conditions of the UCA, including that your Contributions are your original creation and that you have complete right and authority to make your Contributions.
+
+## Once you have a change ready following these ground rules. Simply make a pull request in Github

CONTRIBUTIONS.md.meta

+fileFormatVersion: 2
+guid: 8b1e4e7d7a7bd564dab213b3b4bda399
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.shadergraph/Editor/Data/Interfaces/IHasSettings.cs

+using UnityEngine.Experimental.UIElements;
+
+namespace UnityEditor.Graphing
+{
+    public interface IHasSettings
+    {
+        VisualElement CreateSettingsElement();
+    }
+}
+

com.unity.shadergraph/Editor/Data/Interfaces/IHasSettings.cs.meta

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

com.unity.shadergraph/Editor/Drawing/Views/NodeSettingsView.cs

+using System;
+using System.Linq;
+using UnityEditor.Graphing;
+using UnityEngine;
+using UnityEngine.Experimental.UIElements;
+
+namespace UnityEditor.ShaderGraph.Drawing
+{
+    public class NodeSettingsView : VisualElement
+    {
+        VisualElement m_ContentContainer;
+
+        public NodeSettingsView()
+        {
+            pickingMode = PickingMode.Ignore;
+            AddStyleSheetPath("Styles/NodeSettings");
+            var uxml = Resources.Load<VisualTreeAsset>("UXML/NodeSettings");
+            uxml.CloneTree(this, null);
+            // Get the element we want to use as content container
+            m_ContentContainer = this.Q("contentContainer");
+            RegisterCallback<MouseDownEvent>(OnMouseDown);
+            RegisterCallback<MouseUpEvent>(OnMouseUp);
+        }
+
+        void OnMouseUp(MouseUpEvent evt)
+        {
+            evt.StopPropagation();
+        }
+
+        void OnMouseDown(MouseDownEvent evt)
+        {
+            evt.StopPropagation();
+        }
+
+        public override VisualElement contentContainer
+        {
+            get { return m_ContentContainer; }
+        }
+    }
+}
+
+

com.unity.shadergraph/Editor/Drawing/Views/NodeSettingsView.cs.meta

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

com.unity.shadergraph/Editor/Drawing/Views/PBRSettingsView.cs

+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor.Experimental.UIElements;
+using UnityEngine;
+using UnityEngine.Experimental.UIElements;
+using UnityEditor.Graphing.Util;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+
+namespace UnityEditor.ShaderGraph.Drawing
+{
+    public class PBRSettingsView : VisualElement
+    {
+        PBRMasterNode m_Node;
+        public PBRSettingsView(PBRMasterNode node)
+        {
+            m_Node = node;
+
+            PropertySheet ps = new PropertySheet();
+
+            ps.Add(new PropertyRow(new Label("Workflow")), (row) =>
+            {
+                row.Add(new EnumField(PBRMasterNode.Model.Metallic), (field) =>
+                {
+                    field.value = m_Node.model;
+                    field.OnValueChanged(ChangeWorkFlow);
+                });
+            });
+
+            ps.Add(new PropertyRow(new Label("Surface")), (row) =>
+            {
+                row.Add(new EnumField(SurfaceType.Opaque), (field) =>
+                {
+                    field.value = m_Node.surfaceType;
+                    field.OnValueChanged(ChangeSurface);
+                });
+            });
+
+            ps.Add(new PropertyRow(new Label("Blend")), (row) =>
+            {
+                row.Add(new EnumField(AlphaMode.Additive), (field) =>
+                {
+                    field.value = m_Node.alphaMode;
+                    field.OnValueChanged(ChangeAlphaMode);
+                });
+            });
+
+            ps.Add(new PropertyRow(new Label("Two Sided")), (row) =>
+            {
+                row.Add(new Toggle(null), (toggle) =>
+                {
+                    toggle.value = m_Node.twoSided.isOn;
+                    toggle.OnToggle(ChangeTwoSided);
+                });
+            });
+
+            Add(ps);
+        }
+
+        void ChangeWorkFlow(ChangeEvent<Enum> evt)
+        {
+            if (Equals(m_Node.model, evt.newValue))
+                return;
+
+            m_Node.owner.owner.RegisterCompleteObjectUndo("Work Flow Change");
+            m_Node.model = (PBRMasterNode.Model)evt.newValue;
+        }
+
+        void ChangeSurface(ChangeEvent<Enum> evt)
+        {
+            if (Equals(m_Node.surfaceType, evt.newValue))
+                return;
+
+            m_Node.owner.owner.RegisterCompleteObjectUndo("Surface Change");
+            m_Node.surfaceType = (SurfaceType)evt.newValue;
+        }
+
+        void ChangeAlphaMode(ChangeEvent<Enum> evt)
+        {
+            if (Equals(m_Node.alphaMode, evt.newValue))
+                return;
+
+            m_Node.owner.owner.RegisterCompleteObjectUndo("Alpha Mode Change");
+            m_Node.alphaMode = (AlphaMode)evt.newValue;
+        }
+
+        void ChangeTwoSided()
+        {
+            m_Node.owner.owner.RegisterCompleteObjectUndo("Two Sided Change");
+            ToggleData td = m_Node.twoSided;
+            td.isOn ^= true;
+            m_Node.twoSided = td;
+        }
+    }
+}

com.unity.shadergraph/Editor/Drawing/Views/PBRSettingsView.cs.meta

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

com.unity.shadergraph/Editor/Drawing/Views/PropertyRow.cs

+using System.Linq;
+using UnityEngine.Experimental.UIElements;
+
+namespace UnityEditor.ShaderGraph.Drawing
+{
+    public class PropertyRow : VisualElement
+    {
+        VisualElement m_ContentContainer;
+        VisualElement m_LabelContainer;
+
+        public override VisualElement contentContainer
+        {
+            get { return m_ContentContainer; }
+        }
+
+        public VisualElement label
+        {
+            get { return m_LabelContainer.FirstOrDefault(); }
+            set
+            {
+                var first = m_LabelContainer.FirstOrDefault();
+                if (first != null)
+                    first.RemoveFromHierarchy();
+                m_LabelContainer.Add(value);
+            }
+        }
+
+        public PropertyRow(VisualElement label = null)
+        {
+            AddStyleSheetPath("Styles/PropertyRow");
+            VisualElement container = new VisualElement {name = "container"};
+            m_ContentContainer = new VisualElement { name = "content"  };
+            m_LabelContainer = new VisualElement {name = "label" };
+            m_LabelContainer.Add(label);
+
+            container.Add(m_LabelContainer);
+            container.Add(m_ContentContainer);
+
+            shadow.Add(container);
+        }
+    }
+}

com.unity.shadergraph/Editor/Drawing/Views/PropertyRow.cs.meta

+fileFormatVersion: 2
+guid: 917a1d0b14b14ca0861b93792b550f83
+timeCreated: 1521637416

com.unity.shadergraph/Editor/Drawing/Views/PropertySheet.cs

+using System.Linq;
+using UnityEditorInternal;
+using UnityEngine.Experimental.UIElements;
+
+namespace UnityEditor.ShaderGraph.Drawing
+{
+    public class PropertySheet : VisualElement
+    {
+        VisualElement m_ContentContainer;
+        VisualElement m_HeaderContainer;
+        Label m_Header;
+        public override VisualElement contentContainer
+        {
+            get { return m_ContentContainer; }
+        }
+
+        public VisualElement headerContainer
+        {
+            get { return m_HeaderContainer.FirstOrDefault(); }
+            set
+            {
+                var first = m_HeaderContainer.FirstOrDefault();
+                if( first != null )
+                    first.RemoveFromHierarchy();
+
+                m_HeaderContainer.Add(value);
+            }
+        }
+
+        public PropertySheet(Label header = null)
+        {
+            AddStyleSheetPath("Styles/PropertySheet");
+            m_ContentContainer = new VisualElement { name = "content" };
+            m_HeaderContainer = new VisualElement { name = "header" };
+            if( header != null)
+                m_HeaderContainer.Add(header);
+
+            m_ContentContainer.Add(m_HeaderContainer);
+            shadow.Add(m_ContentContainer);
+        }
+    }
+}

com.unity.shadergraph/Editor/Drawing/Views/PropertySheet.cs.meta

+fileFormatVersion: 2
+guid: 145d8ce4e0814506803af49f799cdb02
+timeCreated: 1521645038

com.unity.shadergraph/Editor/Drawing/Views/UnlitSettingsView.cs

+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor.Experimental.UIElements;
+using UnityEngine;
+using UnityEngine.Experimental.UIElements;
+using UnityEditor.Graphing.Util;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+
+namespace UnityEditor.ShaderGraph.Drawing
+{
+    public class UnlitSettingsView : VisualElement
+    {
+        UnlitMasterNode m_Node;
+        public UnlitSettingsView(UnlitMasterNode node)
+        {
+            m_Node = node;
+
+            PropertySheet ps = new PropertySheet();
+
+            ps.Add(new PropertyRow(new Label("Surface")), (row) =>
+            {
+                row.Add(new EnumField(SurfaceType.Opaque), (field) =>
+                {
+                    field.value = m_Node.surfaceType;
+                    field.OnValueChanged(ChangeSurface);
+                });
+            });
+
+            ps.Add(new PropertyRow(new Label("Blend")), (row) =>
+            {
+                row.Add(new EnumField(AlphaMode.Additive), (field) =>
+                {
+                    field.value = m_Node.alphaMode;
+                    field.OnValueChanged(ChangeAlphaMode);
+                });
+            });
+
+            ps.Add(new PropertyRow(new Label("Two Sided")), (row) =>
+            {
+                row.Add(new Toggle(null), (toggle) =>
+                {
+                    toggle.value = m_Node.twoSided.isOn;
+                    toggle.OnToggle(ChangeTwoSided);
+                });
+            });
+
+            Add(ps);
+        }
+
+        void ChangeSurface(ChangeEvent<Enum> evt)
+        {
+            if (Equals(m_Node.surfaceType, evt.newValue))
+                return;
+
+            m_Node.owner.owner.RegisterCompleteObjectUndo("Surface Change");
+            m_Node.surfaceType = (SurfaceType)evt.newValue;
+        }
+
+        void ChangeAlphaMode(ChangeEvent<Enum> evt)
+        {
+            if (Equals(m_Node.alphaMode, evt.newValue))
+                return;
+
+            m_Node.owner.owner.RegisterCompleteObjectUndo("Alpha Mode Change");
+            m_Node.alphaMode = (AlphaMode)evt.newValue;
+        }
+
+        void ChangeTwoSided()
+        {
+            m_Node.owner.owner.RegisterCompleteObjectUndo("Two Sided Change");
+            ToggleData td = m_Node.twoSided;
+            td.isOn ^= true;
+            m_Node.twoSided = td;
+        }
+    }
+}

com.unity.shadergraph/Editor/Drawing/Views/UnlitSettingsView.cs.meta

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

com.unity.shadergraph/Editor/Resources/Icons.meta

+fileFormatVersion: 2
+guid: f4d6d4aaf7f25a14fb15dabc0b24d7ef
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.shadergraph/Editor/Resources/Styles/NodeSettings.uss

+NodeSettingsView {
+	width: 232;
+	position-type: absolute;
+	slice-top: 40;
+	slice-left: 80;
+	slice-right: 25;
+	slice-bottom: 25;
+	padding-top: 15;
+	padding-left: 4;
+	padding-right: 4;
+	padding-bottom: 4;
+	background-image: resource("Icons/Settings_Flyout_9slice");
+}
+
+NodeSettingsView > #mainContainer {
+	padding-top: 4;
+	padding-left: 4;
+	padding-right: 4;
+	padding-bottom: 4;
+}

com.unity.shadergraph/Editor/Resources/Styles/NodeSettings.uss.meta

+fileFormatVersion: 2
+guid: 59bba4c88ab5f464d9a8f51088561c48
+ScriptedImporter:
+  fileIDToRecycleName:
+    11400000: stylesheet
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}

com.unity.shadergraph/Editor/Resources/Styles/PropertyNameReferenceField.uss

+TextField.modified {
+    font-style: bold;
+}

com.unity.shadergraph/Editor/Resources/Styles/PropertyNameReferenceField.uss.meta

+fileFormatVersion: 2
+guid: 93842094f0dbac941bac7d2af67241b3
+ScriptedImporter:
+  fileIDToRecycleName:
+    11400000: stylesheet
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}

com.unity.shadergraph/Editor/Resources/Styles/PropertyRow.uss

+PropertyRow EnumField,
+PropertyRow Label,
+PropertyRow Toggle,
+PropertyRow DoubleField {
+    margin-left: 0;
+    margin-right: 0;
+}
+
+PropertyRow > #container{
+	flex-grow: 1;
+	padding-left: 8;
+	padding-right: 8;
+	flex-direction: row;
+}
+
+PropertyRow > #container > #label {
+	width: 75;
+	height: 24;
+	justify-content: center;
+}
+
+PropertyRow > #container > #label > Label {
+	margin-bottom: 3;
+}
+
+PropertyRow > #container > #content{
+	flex-grow: 1;
+	height: 24;
+	justify-content: center;
+}
+

com.unity.shadergraph/Editor/Resources/Styles/PropertyRow.uss.meta

+fileFormatVersion: 2
+guid: 2af887df8cf23de4f9bf550f4e917c18
+ScriptedImporter:
+  fileIDToRecycleName:
+    11400000: stylesheet
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}

com.unity.shadergraph/Editor/Resources/Styles/PropertySheet.uss

+PropertySheet {
+    margin-top: 4;
+    margin-bottom: 4;
+}
+PropertySheet > #content > #header{
+    margin-left: 4;
+}
+
+PropertySheet > #content > #header > Label{
+    text-color: #C1C1C1;
+    font-size: 11;
+    font-style: bold;
+}

com.unity.shadergraph/Editor/Resources/Styles/PropertySheet.uss.meta

+fileFormatVersion: 2
+guid: acd20f0eca2b65544b43e657d5d713fe
+ScriptedImporter:
+  fileIDToRecycleName:
+    11400000: stylesheet
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}

com.unity.shadergraph/Editor/Resources/Styles/ShaderGraphBlackboard.uss

+.sgblackboardFieldPropertyView * {
+    font-size: 11;
+}
+.sgblackboardFieldPropertyView > .rowView {
+    flex-direction: row;
+    padding-left: 10;
+    padding-right: 2;
+    padding-top: 2;
+    padding-bottom: 2;
+}
+
+.sgblackboardFieldPropertyView > .rowView > .rowViewLabel {
+    min-width: 50;
+}
+
+.sgblackboardFieldPropertyView > .rowView > .rowViewControl {
+    flex: 1;
+}

com.unity.shadergraph/Editor/Resources/Styles/ShaderGraphBlackboard.uss.meta

+fileFormatVersion: 2
+guid: 381f1cbb2f6577e408bed4c5f6208020
+ScriptedImporter:
+  fileIDToRecycleName:
+    11400000: stylesheet
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}

com.unity.shadergraph/Editor/Resources/UXML/NodeSettings.uxml

+<UXML xmlns:ui="UnityEngine.Experimental.UIElements">
+    <ui:VisualElement name="mainContainer">
+		<ui:VisualElement name="contentContainer">
+		</ui:VisualElement>
+    </ui:VisualElement>   
+</UXML>
+

com.unity.shadergraph/Editor/Resources/UXML/NodeSettings.uxml.meta

+fileFormatVersion: 2
+guid: b70651993c98eda43810c32b7416a21b
+ScriptedImporter:
+  fileIDToRecycleName:
+    11400000: tree
+    11400002: inlineStyle
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}

.data/menu_settings.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:5cf6750c4e57c8867fef65f78604bf7b9cd972c2f8ffd910175bd1d69c2d8904
+size 27931

.data/editable_property_references.gif

+version https://git-lfs.github.com/spec/v1
+oid sha256:d7d0960110016f6fc5413b9ae8b2e7289798ebebe8b6b8866d722296041e3c16
+size 66046

com.unity.shadergraph/Editor/Resources/Icons/settings_button.png.meta

+fileFormatVersion: 2
+guid: 3140f217cba5a6f4ca8d41675ac44819
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 5
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: 1
+    mipBias: -1
+    wrapU: 1
+    wrapV: 1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.shadergraph/Editor/Resources/Icons/settingsbutton.png.meta

+fileFormatVersion: 2
+guid: c881a10bb6578f04ba6d52f6c3f0c9d6
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 5
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: 1
+    mipBias: -1
+    wrapU: 1
+    wrapV: 1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.shadergraph/Editor/Resources/Icons/SettingsIcons.png.meta

+fileFormatVersion: 2
+guid: 53bf71ace226b574d88c828e8b631aae
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 5
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: 1
+    mipBias: -1
+    wrapU: 1
+    wrapV: 1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.shadergraph/Editor/Resources/Icons/SettingsIcons@2x.png.meta

+fileFormatVersion: 2
+guid: 66e0f20149bec7a4eaee2f2d8aec158a
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 5
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: 1
+    mipBias: -1
+    wrapU: 1
+    wrapV: 1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.shadergraph/Editor/Resources/Icons/SettingsIcons_hover.png.meta

+fileFormatVersion: 2
+guid: 6bfd5f3c15e1ee7498657be747544985
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 5
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: 1
+    mipBias: -1
+    wrapU: 1
+    wrapV: 1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.shadergraph/Editor/Resources/Icons/SettingsIcons_hover@2x.png.meta

+fileFormatVersion: 2
+guid: b1b079d053c3d0c41952dadf32a89ffd
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 5
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: 1
+    mipBias: -1
+    wrapU: 1
+    wrapV: 1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.shadergraph/Editor/Resources/Icons/Settings_Flyout_9slice.png.meta

+fileFormatVersion: 2
+guid: 57517c89a809f44458493cef0310e46f
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 5
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: 1
+    mipBias: -1
+    wrapU: 1
+    wrapV: 1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.shadergraph/Editor/Resources/Icons/Settings_Flyout_9slice@2x.png.meta

+fileFormatVersion: 2
+guid: a6abafca3e442ca4d970a1f8a2c70b0a
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 5
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: 1
+    mipBias: -1
+    wrapU: 1
+    wrapV: 1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.shadergraph/Editor/Resources/Icons/SettingsIcons.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:7bb1ebd9a31dfccc2bbf117aeab310659b9f3070cc9b13888792a9fd2cc7712a
+size 407

com.unity.shadergraph/Editor/Resources/Icons/SettingsIcons@2x.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:4a32aec42374252c8e1496e9ecb786d05f97ecc98bd22a0a86e646171aaa6cfe
+size 868

com.unity.shadergraph/Editor/Resources/Icons/SettingsIcons_hover.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:af25f27b7ae2e7090acc262568e9a1bd1c0467d4fe67368723a28554d0e97f42
+size 380

com.unity.shadergraph/Editor/Resources/Icons/SettingsIcons_hover@2x.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:3deac69801719035d64f7d33fba8d302899f9f58053d5e17ded0749acb3396ac
+size 808

com.unity.shadergraph/Editor/Resources/Icons/Settings_Flyout_9slice.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:a74ea891a33bbd154d206ed1e7cedfab1d69d30a6c32831eba48ca9613a4e4f4
+size 1920

com.unity.shadergraph/Editor/Resources/Icons/Settings_Flyout_9slice@2x.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:4cfdbf24d0839a3f991e67892e81ff1fbd71f46b185f8312b099dc2c66165f01
+size 4978

com.unity.shadergraph/Editor/Resources/Icons/settings_button.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:35c991fe8259e0caa1ff74c226f7bfc4b0b0d0680d75afb1711da8cc96407f1a
+size 809

com.unity.shadergraph/Editor/Resources/Icons/settingsbutton.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:4f76e1a85f625a61ce4cf7670e2f7664d24335a02ca3033f05424124b44bd27b
+size 397