ShaderGraph #include_with_pragmas for CustomFunction node

[Canijo]

I am in the process of updating some ShaderGraph’s that i’ve been using in old projects.

This ShaderGraphs use CustomFunction nodes to import HLSL related to custom lighting, and they include #pragma directives to define custom Keywords that are later enabled/disabled through a custom inspector.

Currently all hlsl files included through the CustomFunction node are added to the shader as simple #include directives. However, in current versions i need #include_with_pragmas for them to work.

I cannot find any option that could allow me to change the way they are included.

Currently my only way to make them work is going to “View Generated Shader”, and make a new .shader after modifying all relevant #include’s to #include_with_pragmas. But it’s awfully inconvenient and has to be done each time i edit them (and for builds, it also has to be done per platform or the code wont be compatible).

Is there any chance that this feature already exists and im just not seeing it?
If not, is this known by the team and done on purpose to avoid some kind of problem? Or could i hope for this to be implemented?

[Canijo]

I found a post with a similar issue, and posted a reply with a temporary fix by modifying the ShaderGraph package.

@Canijo

Ok so in case anyone is as impatient as me and needs this right now xD

Override the ShaderGraph package (move it from “Library/PackageCache” to the “Packages” folder on your project) and override the following:

• CustomFunctionNode.cs

class CustomFunctionNode : AbstractMaterialNode, IGeneratesBodyCode, IGeneratesFunction, IMayRequireTransform
    {
        // ...
        // add this serializable field for the pragma include
        [SerializeField]
        private bool m_IncludeWithPragmas = false;
        
        public bool includeWithPragmas
        {
            get => m_IncludeWithPragmas;
            set => m_IncludeWithPragmas = value;
        }

        // on this method, add the following
        public void GenerateNodeFunction(FunctionRegistry registry, GenerationMode generationMode)
        {
              // ...
              // find this line
              // registry.RequiresIncludePath(path);

              // and change it to this
              registry.RequiresIncludePath(path, m_IncludeWithPragmas);

              // ...
        }

• HlslFunctionView.cs

internal class HlslFunctionView : VisualElement
    {
         // on this method, add the following
        private void Draw(CustomFunctionNode node)
        {
            // ...
            // at the end of the method:
            var includeWithPragmasToggle = new Toggle()
            {
                value = node.includeWithPragmas
            };
            includeWithPragmasToggle.RegisterValueChangedCallback(
                change =>
                {
                    if (node.includeWithPragmas == change.newValue)
                        return;
                    node.owner.owner.RegisterCompleteObjectUndo("Change Include With Pragmas");
                    node.includeWithPragmas = change.newValue;
                    node.ValidateNode();
                    node.Dirty(ModificationScope.Graph);
                }
            );
            var includePragmaRow = new VisualElement() { name = "Row" };
            includePragmaRow.Add(new Label("With Pragmas"));
            includePragmaRow.Add(includeWithPragmasToggle);
            Add(includePragmaRow);
        }

And at least now its implemented xD. I hope eventually something similar is added to ShaderGraph!