[SG] Custom Includes, Pragmas and Defines

Author: FredMoreau

Packages/com.unity.shadergraph/Editor/Data/Graphs/GraphData.cs

@@ -335,6 +335,49 @@ public GraphPrecision graphDefaultPrecision
             }
         }
 
+        #region Custom Graph Settings
+        [SerializeField]
+        internal List<string> m_CustomPragmas = new();
+
+        [Serializable]
+        internal struct CustomDefineDescriptor
+        {
+            [SerializeField] string m_Define;
+            [SerializeField] bool m_Enabled;
+
+            public CustomDefineDescriptor(string define)
+            {
+                this.m_Define = define;
+                this.m_Enabled = true;
+            }
+
+            public string Define { get => m_Define; set => m_Define = value; }
+            public bool Enabled { get => m_Enabled; set => m_Enabled = value; }
+            public bool IsValid => !String.IsNullOrEmpty(m_Define);
+        }
+
+        [SerializeField]
+        internal List<CustomDefineDescriptor> m_CustomDefines = new();
+
+        [Serializable]
+        internal struct CustomIncludeDescriptor
+        {
+            [SerializeField] ShaderInclude m_Include;
+            [SerializeField] bool m_IncludeWithPragmas;
+
+            public static implicit operator IncludeDescriptor(CustomIncludeDescriptor incl) =>
+                new IncludeDescriptor(AssetDatabase.AssetPathToGUID(incl.IncludePath), incl.IncludePath, IncludeLocation.Graph, new FieldCondition[0] { }, incl.IncludeWithPragmas);
+
+            public ShaderInclude Include { get => m_Include; set => m_Include = value; }
+            public string IncludePath => AssetDatabase.GetAssetPath(m_Include);
+            public bool IncludeWithPragmas { get => m_IncludeWithPragmas; set => m_IncludeWithPragmas = value; }
+            public bool IsValid => m_Include != null;
+        }
+
+        [SerializeField]
+        internal List<CustomIncludeDescriptor> m_CustomIncludes = new();
+        #endregion // Custom Graph Settings
+
         public ConcretePrecision graphDefaultConcretePrecision
         {
             get
@@ -2071,6 +2114,11 @@ public void ReplaceWith(GraphData other)
             m_PreviewMode = other.m_PreviewMode;
             m_OutputNode = other.m_OutputNode;
 
+            m_CustomPragmas.CopyFrom(other.m_CustomPragmas);
+            m_CustomDefines.CopyFrom(other.m_CustomDefines);
+            m_CustomIncludes.CopyFrom(other.m_CustomIncludes);
+            m_SubDatas.CopyFrom(other.m_SubDatas);
+
             if ((this.vertexContext.position != other.vertexContext.position) ||
                 (this.fragmentContext.position != other.fragmentContext.position))
             {

Packages/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/GraphDataPropertyDrawer.cs

@@ -10,6 +10,7 @@
 using UnityEngine.UIElements;
 using UnityEditorInternal;
 using UnityEditor.ShaderGraph.Serialization;
+using System.Text.RegularExpressions;
 
 namespace UnityEditor.ShaderGraph.Drawing.Inspector.PropertyDrawers
 {
@@ -18,21 +19,237 @@ public class GraphDataPropertyDrawer : IPropertyDrawer
     {
         public delegate void ChangeGraphDefaultPrecisionCallback(GraphPrecision newDefaultGraphPrecision);
         public delegate void PostTargetSettingsChangedCallback();
+        internal delegate void GraphSettingsChangedCallback();
 
+        GraphSettingsChangedCallback m_changeGraphSettingsCallback;
         PostTargetSettingsChangedCallback m_postChangeTargetSettingsCallback;
         ChangeGraphDefaultPrecisionCallback m_changeGraphDefaultPrecisionCallback;
 
+        bool m_AdvancedSettingsFoldout;
+        const string customPragmaTooltip = @"The following pragmas will be added in the given order, after other pragmas.
+Enter what comes after '#pragma' (e.g.: enable_debug_symbols or use_dxc)";
+        const string customDefineTooltip = @"The following defines will be added in the given order, after other graph defines.
+Enter what comes after '#define' (e.g.: _DEBUG or MAX_STEPS 32 // your comments.)
+Uncheck the checkbox to temporarily disable the define.";
+        const string customIncludeTooltip = @"The following hlsl files will be included in the given order, prior to other graph includes (e.g.: Custom Function Nodes).";
+
         Dictionary<Target, bool> m_TargetFoldouts = new Dictionary<Target, bool>();
         Dictionary<AbstractShaderGraphDataExtension, bool> m_SubDataFoldouts = new Dictionary<AbstractShaderGraphDataExtension, bool>();
 
-        public void GetPropertyData(
+        internal void GetPropertyData(
             PostTargetSettingsChangedCallback postChangeValueCallback,
+            GraphSettingsChangedCallback changeGraphSettingsCallback,
             ChangeGraphDefaultPrecisionCallback changeGraphDefaultPrecisionCallback)
         {
             m_postChangeTargetSettingsCallback = postChangeValueCallback;
+            m_changeGraphSettingsCallback = changeGraphSettingsCallback;
             m_changeGraphDefaultPrecisionCallback = changeGraphDefaultPrecisionCallback;
         }
 
+        VisualElement GetAdvancedSettings(GraphData graphData, Action onChange)
+        {
+            var element = new VisualElement() { name = "advGraphSettings" };
+
+            void RegisterActionToUndo(string actionName)
+            {
+                graphData.owner.RegisterCompleteObjectUndo(actionName);
+            }
+
+            // Advanced Settings
+            var advancedSettingsFoldout = new Foldout() { text = "Preprocessor Directives", value = m_AdvancedSettingsFoldout, name = "advGraphSettings" };
+            advancedSettingsFoldout.style.unityFontStyleAndWeight = FontStyle.Bold;
+            element.Add(advancedSettingsFoldout);
+            advancedSettingsFoldout.AddToClassList("MainFoldout");
+            advancedSettingsFoldout.RegisterValueChangedCallback(evt =>
+            {
+                m_AdvancedSettingsFoldout = evt.newValue;
+                advancedSettingsFoldout.value = evt.newValue;
+                onChange();
+            });
+
+            if (advancedSettingsFoldout.value)
+            {
+                var advancedSettingsElement = new VisualElement();
+                element.Add(advancedSettingsElement);
+
+                // Custom Pragmas
+                var customPragmasList = new ReorderableListView<string>(
+                    graphData.m_CustomPragmas,
+                    new GUIContent("Pragmas", customPragmaTooltip));
+
+                customPragmasList.OnBeforeChangeCallback +=
+                    (ReorderableListView<string>.ListActionType changeType) =>
+                    {
+                        RegisterActionToUndo($"{changeType} Pragma");
+                    };
+
+                customPragmasList.OnChangeCallback +=
+                    (ReorderableListView<string>.ListActionType changeType) =>
+                    {
+                        onChange();
+                    };
+
+                customPragmasList.DrawItemCallback += (Rect rect, int idx) =>
+                {
+                    EditorGUI.BeginChangeCheck();
+                    var data = graphData.m_CustomPragmas[idx];
+                    data = EditorGUI.DelayedTextField(rect, "", data);
+
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        RegisterActionToUndo("Change Pragma");
+                        data = ValidatePragma(data);
+                        graphData.m_CustomPragmas[idx] = data;
+                        onChange();
+                    }
+                };
+
+                advancedSettingsElement.Add(customPragmasList);
+
+                // Custom Defines
+                var customDefineList = new ReorderableListView<GraphData.CustomDefineDescriptor>(
+                    graphData.m_CustomDefines,
+                    new GUIContent("Local Defines", customDefineTooltip));
+
+                customDefineList.OnNewItemCallback += () => new GraphData.CustomDefineDescriptor("_DEFINE");
+
+                customDefineList.OnBeforeChangeCallback +=
+                    (ReorderableListView<GraphData.CustomDefineDescriptor>.ListActionType changeType) =>
+                    {
+                        RegisterActionToUndo($"{changeType} Local Define");
+                    };
+
+                customDefineList.OnChangeCallback +=
+                    (ReorderableListView<GraphData.CustomDefineDescriptor>.ListActionType changeType) =>
+                    {
+                        onChange();
+                    };
+
+                customDefineList.DrawItemCallback += (Rect rect, int idx) =>
+                {
+                    Rect objectFieldRect = new Rect(rect.x, rect.y, rect.width - 24, rect.height);
+                    Rect toggleRect = new Rect(objectFieldRect.max.x+8, rect.y, 24, rect.height);
+
+                    var data = graphData.m_CustomDefines[idx];
+
+                    EditorGUI.BeginChangeCheck();
+                    data.Define = EditorGUI.DelayedTextField(objectFieldRect, new GUIContent("", ""), data.Define);
+                    data.Enabled = EditorGUI.ToggleLeft(toggleRect, "", data.Enabled);
+
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        RegisterActionToUndo("Change Local Define");
+                        data.Define = ValidateDefine(data.Define);
+                        graphData.m_CustomDefines[idx] = data;
+                        onChange();
+                    }
+                };
+
+                advancedSettingsElement.Add(customDefineList);
+
+                // Custom Includes
+                var customIncludeList = new ReorderableListView<GraphData.CustomIncludeDescriptor>(
+                    graphData.m_CustomIncludes,
+                    new GUIContent("Graph Includes", customIncludeTooltip));
+
+                customIncludeList.OnNewItemCallback += () => new GraphData.CustomIncludeDescriptor();
+
+                customIncludeList.OnBeforeChangeCallback +=
+                    (ReorderableListView<GraphData.CustomIncludeDescriptor>.ListActionType changeType) =>
+                    {
+                        RegisterActionToUndo($"{changeType} Graph Include");
+                    };
+
+                customIncludeList.OnChangeCallback +=
+                    (ReorderableListView<GraphData.CustomIncludeDescriptor>.ListActionType changeType) =>
+                    {
+                        onChange();
+                    };
+
+                customIncludeList.DrawItemCallback += (Rect rect, int idx) =>
+                {
+                    const float labelWidth = 85f;
+                    Rect objectFieldRect = new Rect(rect.x, rect.y, rect.width - (labelWidth + 24), rect.height);
+                    Rect toggleRect = new Rect(objectFieldRect.max.x + 8, rect.y, labelWidth + 24, rect.height);
+
+                    EditorGUI.BeginChangeCheck();
+                    var data = graphData.m_CustomIncludes[idx];
+                    var previousLabelWidth = EditorGUIUtility.labelWidth;
+                    EditorGUIUtility.labelWidth = labelWidth;
+                    data.Include = (ShaderInclude)EditorGUI.ObjectField(objectFieldRect, "", data.Include, typeof(ShaderInclude), false);
+                    data.IncludeWithPragmas = EditorGUI.Toggle(toggleRect, new GUIContent("with pragmas", "Should the pragma directives in the include also be included."), data.IncludeWithPragmas);
+                    EditorGUIUtility.labelWidth = previousLabelWidth;
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        RegisterActionToUndo("Change Graph Include");
+                        graphData.m_CustomIncludes[idx] = data;
+                        onChange();
+                    }
+                };
+
+                advancedSettingsElement.Add(customIncludeList);
+            }
+
+            return element;
+        }
+
+        static string ValidatePragma(string input)
+        {
+            if (string.IsNullOrWhiteSpace(input))
+                return "";
+
+            if (input.StartsWith("#pragma "))
+                return input.Replace("#pragma ", "");
+
+            return input;
+        }
+
+        static string ValidateDefine(string input)
+        {
+            if (string.IsNullOrWhiteSpace(input))
+                return "";
+
+            if (input.StartsWith("#define "))
+                input = input.Replace("#define ", "");
+
+            // Split comment
+            string comment = "";
+            var commentMatch = Regex.Match(input, @"//.*$");
+            if (commentMatch.Success)
+            {
+                comment = commentMatch.Value;
+                input = input.Substring(0, commentMatch.Index);
+            }
+
+            // Normalize whitespace
+            input = Regex.Replace(input, @"\s+", " ").Trim();
+
+            var parts = input.Split(' ', StringSplitOptions.RemoveEmptyEntries);
+
+            if (parts.Length == 0)
+                return "";
+
+            // Clean NAME
+            string name = Regex.Replace(parts[0], @"[^A-Za-z0-9_]", "");
+            if (Regex.IsMatch(name, @"^[0-9]"))
+                name = "_" + name;
+
+            // Clean VALUE
+            string value = "";
+            if (parts.Length > 1)
+                value = Regex.Replace(parts[1], @"[^A-Za-z0-9_]", "");
+
+            // Rebuild
+            string result = name;
+            if (!string.IsNullOrEmpty(value))
+                result += " " + value;
+
+            if (!string.IsNullOrEmpty(comment))
+                result += " " + comment;
+
+            return result;
+        }
+
         VisualElement GetSettings(GraphData graphData, Action onChange)
         {
             var element = new VisualElement() { name = "graphSettings" };
@@ -45,7 +262,7 @@ void RegisterActionToUndo(string actionName)
                 graphData.owner.RegisterCompleteObjectUndo(actionName);
             }
 
-            // Add Label
+            // Targets
             var targetSettingsLabel = new Label("Target Settings");
             targetSettingsLabel.style.unityFontStyleAndWeight = FontStyle.Bold;
             element.Add(new PropertyRow(targetSettingsLabel));
@@ -256,6 +473,9 @@ internal VisualElement CreateGUI(GraphData graphData)
 
             propertySheet.Add(GetSettings(graphData, () => this.m_postChangeTargetSettingsCallback()));
 
+            if (!graphData.isSubGraph)
+                propertySheet.Add(GetAdvancedSettings(graphData, () => this.m_changeGraphSettingsCallback()));
+
             return propertySheet;
         }
 

Packages/com.unity.shadergraph/Editor/Drawing/Inspector/PropertyDrawers/SwitchNodePropertyDrawer.cs

@@ -1,8 +1,7 @@
 using System;
 using UnityEditor.Graphing;
-using UnityEngine.UIElements;
 using UnityEngine;
-using System.Collections.Generic;
+using UnityEngine.UIElements;
 
 namespace UnityEditor.ShaderGraph.Drawing.Inspector.PropertyDrawers
 {
@@ -33,17 +32,23 @@ internal override void AddCustomNodeProperties(VisualElement parentElement, Abst
                 return;
 
             var listView = new ReorderableListView<SwitchNode.EntryCase>(node.m_cases, "Conditions");
-            listView.InitializeItemCallback += (List<SwitchNode.EntryCase> List) =>
-            {
-                return new SwitchNode.EntryCase { comparisonType = ComparisonType.Equal, threshold = List.Count };
-            };
 
-            listView.ValueChangedCallback += (List<SwitchNode.EntryCase> list) =>
-            {
-                node.owner.owner.RegisterCompleteObjectUndo("switch Entry List Change");
-                node.Dirty(ModificationScope.Topological);
-                node.UpdateNodeAfterDeserialization();
-            };
+            listView.OnNewItemCallback +=
+                () => new SwitchNode.EntryCase { comparisonType = ComparisonType.Equal, threshold = node.m_cases.Count };
+
+            listView.OnBeforeChangeCallback +=
+                (ReorderableListView<SwitchNode.EntryCase>.ListActionType changeType) =>
+                {
+                    node.owner.owner.RegisterCompleteObjectUndo($"{changeType} Switch Condition");
+                };
+
+            listView.OnChangeCallback +=
+                (ReorderableListView<SwitchNode.EntryCase>.ListActionType changeType) =>
+                {
+                    node.Dirty(ModificationScope.Topological);
+                    node.UpdateNodeAfterDeserialization();
+                    inspectorUpdateDelegate();
+                };
 
             listView.DrawItemCallback += (Rect rect, int idx) =>
             {