Merge pull request #326 from Unity-Technologies/editable-property-reference-names

Editable property reference names

.gitattributes

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

CHANGELOG.md

 
 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))

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)

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; }
 

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;
+            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;

.data/editable_property_references.gif

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

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}