Output Bindings

A Shader's Outputs section does two jobs at once:

1. it declares the variables the Graph will write, and
2. it binds those variables to Unreal material property inputs, or to pins on explicitly created UMaterialExpression nodes.

Bindings, not declarations, are what make a material. A Shader with declarations but no bindings parses with the warning No Outputs block was provided. Generation requires explicit material property bindings. and then fails generation with {File}: Outputs block is required.

Synopsis

Outputs [=]
{
    <output-declaration>…
    <output-binding>…
}

output-declaration := <type> <name> [ = <expression> ] ;

output-binding     := Base. <target> = <source> ;
                    | Expression( <key> = <value> [, <key> = <value> ]… ) . Pin[ <index> ] = <source> ;

<source> is an output variable name, or the reserved name return. The [ and ] around <index> are literal.

Statement classification is per statement, not per section:

Binding target kinds

The Base.<target> catalogue

Target names are matched case-insensitively. Every accepted spelling is listed below; there are no wildcards and no "and others".

46 spellings resolving to 31 distinct EMaterialProperty values on UE 5.4 and newer. On UE 5.3 FrontMaterial does not exist, leaving 45 spellings and 30 properties. Five further spellings exist only in a custom engine fork — see Fork-only targets.

An unrecognized name fails with Unsupported material output '{Name}'.

Fork-only targets

These resolve only when the engine defines MOON_ENGINE. On a stock Unreal build they are Unsupported material output.

Targets with side effects

Two Base. targets change the generated material's render state as a side effect of being bound. They are the only bindings that do so, and both are easy to trip over.

Base.MaterialAttributes

Binding Base.MaterialAttributes sets UMaterial::bUseMaterialAttributes = true — the Use Material Attributes checkbox — so the material exposes the single attributes input instead of the individual property inputs. You do not tick the checkbox yourself, and you cannot un-tick it from the material editor: the property is reset and reapplied on every regeneration.

The bound variable must carry a MaterialAttributes value, otherwise:

{File}: Material output '{Name}' expects a MaterialAttributes value.

Base.FrontMaterial

Binding Base.FrontMaterial:

• force-sets the shading model to Substrate (MSM_Strata);
• requires that Settings either declares ShadingModel="Substrate" (or its accepted alias ShadingModel="Strata") or declares no ShadingModel at all — anything else fails with {File}: Base.FrontMaterial requires ShadingModel="Substrate" or no explicit ShadingModel setting.;
• is mutually exclusive with Base.MaterialAttributes — {File}: Base.FrontMaterial and Base.MaterialAttributes cannot be used by the same Shader.;
• cannot be driven by the whole-surface Custom-node path — {File}: Base.FrontMaterial expects a Substrate value and cannot be driven by a material Custom node. Use a Graph block and Substrate.* nodes.;
• does not exist on UE 5.3, where it reports Base.FrontMaterial requires Unreal Engine 5.4 or newer.

The bound variable must be a Substrate value, produced by the Substrate.* builtins:

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

The Expression( … ).Pin[i] target

Some Unreal outputs are not material property inputs at all — they are custom output nodes sitting loose in the graph. The non-Base binding form creates such a node and connects the source variable to one of its input pins.

Expression( Class = "<ExpressionClass>" [, <key> = <value> ]… ) . Pin[ <index> ] = <source> ;

Requirements, in the order they are checked

Argument keys are normalized — trimmed and lower-cased; values are unquoted and trimmed.

Class resolution

A value containing / or . is loaded directly as an object path, and accepted only if the loaded class derives from UMaterialExpression. Otherwise a candidate list is built — <Value>, plus U<Value>, MaterialExpression<Value> and UMaterialExpression<Value> when <Value> does not already start with that prefix — and every non-abstract UMaterialExpression subclass is scanned for a name equal to any candidate, ignoring case.

The same rule governs Class= everywhere else it appears — see UE.Expression.

Other arguments

Every argument other than Class is written to the same-named reflected property on the created node, using the same literal grammar as declaration metadata. Class stays in the argument map but is skipped when reflected properties are written, so it never produces a "not a property" error.

Pin indices and node reuse

• Pin[<index>] is the zero-based index into the node's input list, in the order the engine declares them. Expression(Class="ThinTranslucentMaterialOutput").Pin[0] is TransmittanceColor and .Pin[1] is SurfaceCoverage.
• An index past the end fails with Output target '{Target}' does not have Pin[{Index}].
• Each pin may be bound once: Output target pin '{Target}' is bound more than once.
• Nodes are de-duplicated by class plus sorted argument list. Two bindings whose Expression( … ) specification is identical share one node and bind different pins; a difference in any argument creates a second node.
• The source variable must have been declared in Outputs: Output variable '{Name}' must declare an explicit type before binding to expression target '{Target}'.
• Created output-target nodes are placed at graph X 1200, Y starting at 200, stepping +220.

Outputs = {
    float3 Transmittance;
    float  Coverage;
    float3 CoatNormal;

    // Both statements reuse one ThinTranslucentMaterialOutput node.
    Expression(Class="ThinTranslucentMaterialOutput").Pin[0] = Transmittance;
    Expression(Class="ThinTranslucentMaterialOutput").Pin[1] = Coverage;

    // A different class -> a second node.
    Expression(Class="ClearCoatNormalCustomOutput").Pin[0] = CoatNormal;
}

The reserved name return

return may be used as a binding source, but never as a declaration name.

In practice return belongs to the whole-surface Custom-node path, where the Shader has no Graph block. Any material with a Graph block should declare named output variables.

Validation rules

Applied after parsing, before any node is created.

Notes

• Bindings and declarations may be interleaved freely; a binding may reference a variable declared later in the same section.
• A repeated Outputs section appends to both lists.
• No [ … ] metadata block is accepted on any Outputs statement in a Shader.
• Each binding is routed through a generated NamedReroute pair, so the material root node stays readable in a large graph. Declarations are named DS_<Sanitized> with an index suffix.
• Binding to a property that the current shading model or blend mode does not use is not diagnosed — Unreal simply leaves the input unread. Check the material editor's greyed-out inputs.

Common errors

The complete cross-stage list is in the diagnostics index.

Worked example

Shader(Name="DreamShaderTests/Corpus/M_Outputs")
{
    Properties = {
        vec3  Tint = vec3(0.4, 0.8, 1.0);
        float A    = 0.75;
    }

    Settings = {
        Domain       = "Surface";
        ShadingModel = "Unlit";
    }

    Outputs = {
        vec3  Color;
        float Alpha;

        Base.EmissiveColor = Color;
        Base.Opacity       = Alpha;
    }

    Graph = {
        Color = Tint;
        Alpha = A;
    }
}

Resulting connections:

UMaterial /Game/DreamShaderTests/Corpus/M_Outputs
  MP_EmissiveColor  <- NamedReroute DS_Color_<n>  <- VectorParameter "Tint"  RGB output
  MP_Opacity        <- NamedReroute DS_Alpha_<n>  <- ScalarParameter "A"     R output
  bUseMaterialAttributes = false

Where next