Substrate Nodes

Substrate.* is a sibling call namespace to UE.* that wraps Unreal's Substrate BSDF, composition and utility material nodes. Each name maps to a fixed expression class — 24 names resolving to 22 distinct classes, because two of them are alias pairs.

Outputs = {
    Substrate Surface;
    Base.FrontMaterial = Surface;
}
Graph = {
    Surface = Substrate.Unlit(EmissiveColor = Glow);
}

Availability

Everything gated on the engine version:

Synopsis

Substrate . <Name> ( [ <argument-name> = <expression> ]
                     [ , <argument-name> = <expression> ] …
                     [ , { Output | OutputName } = "<pin-name>" ]
                     [ , OutputIndex = <integer> ] )

The namespace prefix and the name are matched case-insensitively: SUBSTRATE.UNLIT(…) resolves. Argument names are matched case-insensitively and whitespace-trimmed, but are otherwise exact — no separator stripping.

Argument model

Every Substrate.* call goes through the generic reflected path, so it inherits UE.Expression's rules.

Reflection-driven binding

Argument binding is not table-driven. For each remaining argument the generator tries, in order:

1. Input pin name — every input pin the node reports, compared case-insensitively after trimming.
2. UPROPERTY name — any reflected property on the class or a superclass, compared the same way. Boolean properties additionally match with a leading b stripped.
3. If the property is an FExpressionInput or an FMaterialAttributesInput, the argument becomes a wired input and its value is evaluated as an expression. Otherwise it is written as a literal property.
4. No match → UE.{Name}: '{Argument}' is not a property on '{Class}'.

A pin-name match wins over a reflected property of the same name.

Selecting an output

Output= / OutputName= matches an output pin's name verbatim, case-insensitively, including names that contain spaces — output pin names are matched as whole names, not parsed as argument names. OutputIndex= takes a 0-based index. Only the four utility wrappers have more than one output.

Catalogue

Substrate output marks the wrappers whose result is a Substrate material value — 0 components, bindable to Base.FrontMaterial. The four marked no are the utility nodes and return ordinary numeric values.

The two alias pairs are exact duplicates — same class, same inputs, same output typing. Neither spelling is deprecated.

Output typing

The declared type is then checked against the selected output pin's actual value type. If a wrapper declared as a Substrate output resolves to a pin that is not a Substrate value, the call fails with Substrate.{Name} output is not a Substrate value.

A Substrate value can only be:

• assigned to a Substrate-typed Graph variable or Outputs declaration;
• passed to another Substrate.* wrapper's Substrate-typed input;
• bound to Base.FrontMaterial.

Node reference

BSDFs

Substrate.Slab

The general-purpose Substrate BSDF slab — the one to reach for first.

Substrate.SimpleClearCoat

A slab with a fixed second clear-coat lobe.

Substrate.Unlit

Emissive-only BSDF. The smallest complete Substrate surface.

Substrate.Hair

Substrate.Eye

Substrate.SingleLayerWater

Substrate.VolumetricFogCloud

Participating-media BSDF for volumetric fog and cloud materials.

Substrate.ShadingModels

Legacy-style shading-model surface expressed as a Substrate material. Editor completion offers no parameters for this wrapper; every argument below is still accepted.

Domain output nodes

Substrate.LightFunction

Substrate.PostProcess

Substrate.UI

Conversion

Substrate.ConvertMaterialAttributes

Converts a MaterialAttributes value into a Substrate material.

MaterialAttributes is the reflected property name and Attributes is the engine's pin name for the same input; both bind input 0. Passing a numeric value fails with Substrate.ConvertMaterialAttributes input '{Pin}' expects a MaterialAttributes value.

Substrate.ConvertToDecal

Converts a Substrate material into a decal material.

Composition

Substrate.HorizontalMix

Screen-space horizontal blend of two Substrate materials. Also spelled Substrate.HorizontalMixing — the two names are interchangeable.

Substrate.VerticalLayer

Layers one Substrate material over another. Also spelled Substrate.VerticalLayering — the two names are interchangeable.

Substrate.Add

Substrate.Weight

Scales a Substrate material's contribution.

Substrate.Select

Static selection between two Substrate materials.

Utility nodes

These four return ordinary numeric values, not Substrate values, and they are the only wrappers with more than one output. Select with Output= or OutputIndex=.

Substrate.TransmittanceToMFP

Converts a transmittance colour and thickness into a mean-free-path parameterisation.

Substrate.MetalnessToDiffuseAlbedoF0

Converts a legacy base-colour / metallic / specular triple into the slab parameterisation.

Substrate.HazinessToSecondaryRoughness

Converts a haziness control into a second-roughness lobe.

Note the spaces in those output names. They are matched as whole names, so Output = "Second Roughness Weight" works even though a pin name with spaces would be unreachable as an argument name.

Substrate.ThinFilm

Computes thin-film interference specular colours.

Binding to Base.FrontMaterial

A Substrate material reaches the generated UMaterial through the Base.FrontMaterial output binding, and through no other route.

Outputs = {
    Substrate Surface;              // declared-type token; case-insensitive, no other spelling
    Base.FrontMaterial = Surface;
}
Graph = {
    Surface = Substrate.Unlit(EmissiveColor = Color);
}

Notes worth knowing

• There is no wrapper for every Substrate class. UMaterialExpressionSubstrateToonBSDF has no entry in the catalogue. Reach it — and any future Substrate class — through the generic path:

  UE.Expression(Class = "SubstrateToonBSDF", OutputType = "Substrate", …)

  Class-name resolution accepts SubstrateToonBSDF, MaterialExpressionSubstrateToonBSDF and the full /Script/Engine.… object path interchangeably. The U-prefixed C++ spelling is not accepted — see Class resolution.

• Registered UE.* sugar does not apply inside this namespace. Substrate.TexCoord(…) is not a thing; unknown names fail with Unsupported Substrate builtin call '{Name}' in Graph.

• Substrate nodes do participate in node reuse: two textually identical Substrate.Slab(…) calls over identical argument values collapse to a single node. This is the same cache the generic UE.Expression path uses, and it is why one multi-output utility node can serve two reads with different Output= selectors.

• The decompiler exports an existing Substrate graph back to DreamShaderLang, deriving channel swizzles from each connection's write mask since 1.5.0.

• The complete Substrate.* surface is exported for editor tooling to Saved/DreamShader/Bridge/substrate-builtins.json (schema DreamShader.SubstrateBuiltins, version 1), one entry per name with its qualifiedName, className, outputType, isSubstrateOutput and curated parameters. See Editor tools.

Diagnostics

At the call site

Substrate values elsewhere in the pipeline

The complete list lives in the diagnostics index.

Example

Shader(Name="Docs/M_Substrate")
{
    Properties = {
        vec3  BaseColor = vec3(0.6, 0.1, 0.1);
        float Metallic  = 0.0;
        float Specular  = 0.5;
        float Rough     = 0.3;
        vec3  Glow      = vec3(0.1, 0.6, 1.0);
    }

    Outputs = {
        Substrate Surface;
        Base.FrontMaterial = Surface;
    }

    Graph = {
        // Utility node: two numeric outputs, selected by name.
        vec3 Albedo = Substrate.MetalnessToDiffuseAlbedoF0(
            BaseColor = BaseColor, Metallic = Metallic, Specular = Specular,
            Output = "DiffuseAlbedo");
        vec3 F0 = Substrate.MetalnessToDiffuseAlbedoF0(
            BaseColor = BaseColor, Metallic = Metallic, Specular = Specular,
            Output = "F0");

        Substrate Body = Substrate.Slab(
            DiffuseAlbedo = Albedo,
            F0            = F0,
            Roughness     = Rough);

        Substrate Emissive = Substrate.Unlit(EmissiveColor = Glow);

        Surface = Substrate.Add(A = Body, B = Emissive);
    }
}

Generated nodes:

SubstrateMetalnessToDiffuseAlbedoF0   -> output "DiffuseAlbedo"  -> Albedo    (3 components)
                                      -> output "F0"             -> F0        (3 components)
                                         (one node, reused for both reads)
SubstrateSlabBSDF                     -> Body                    (Substrate value)
SubstrateUnlitBSDF                    -> Emissive                (Substrate value)
SubstrateAdd                          -> Surface                 (Substrate value)
Material ShadingModel forced to Substrate by the Base.FrontMaterial binding

Where to next