Statements

A Graph body is a flat list of statements. There are ten forms, they are separated by ;, and the parser decides which form a piece of text is by a fixed sequence of textual tests — not by keywords. Understanding that classification order explains most of the surprising diagnostics in the language.

Synopsis

graph-statement :=
      [ <type> ] <name> [ = <expression> ] ;                      // declaration / assignment
    | <type> <name> [ = <init> ] , <name> [ = <init> ] … ;        // comma declarators
    | <name> = { <expression> , … } ;                             // brace initializer
    | <name> . <member> = { <expression> | { <expression> , … } } ;
    | <call-expression> ;                                         // statement-form call
    | if ( <condition> ) { <graph-statement> … }
      [ else { <graph-statement> … } | else if ( … ) { … } … ]

The ten forms

Form 8 expands to one statement per declarator. All of them share the type token of the first declarator, and all of them report the same source line and column.

How a body is split

Graph = {
    float a = 1.0;;;             // the empty statements between ; are dropped
    if (a > 0.5) { a = 0.0; }    // no ; needed; the inner ; does not split the if
    float b = a * 2.0            // final statement, ; omitted
}

Classification order

Given one statement's text, the parser tests these rules in order. The first that matches wins.

"Splits into a type and a name" means: split at the last top-level whitespace character, tracking ( ) depth and string state; both halves must be non-empty. That is why UE.Panner(Speed = 0.1) P; is a declaration — the space inside the argument list is not at top level.

Declarations

<type> <name> [ = { <expression> | <brace-initializer> } ]
     [ , <name> [ = { <expression> | <brace-initializer> } ] ] … ;

brace-initializer := { [ <expression> [ , <expression> ] … ] }

Accepted type tokens

Comparison is case-insensitive. For the numeric rows, MaterialAttributes and Substrate, all internal spaces are removed before matching, so float 3 resolves as float3 and Material Attributes as MaterialAttributes. The texture rows and StaticBool are matched on the token as written, so Texture 2D does not resolve.

int, uint, bool and half are alternative spellings of the same float widths — the token fixes the component count and nothing else. The full per-context catalogue is on Types and Values.

Declarations without an initializer

float3 c;              // Constant(0) -> AppendVector -> AppendVector
MaterialAttributes A;  // MakeMaterialAttributes, ready for member writes
Texture2D T;           // error: requires an explicit initializer

Declarations with an initializer

The initializer is evaluated first, then the declaration is typed:

Coercion at step 3 silently narrows a wider value by prefixing an r / rg / rgb mask, and splats a scalar up to the declared width. It never widens 2 components to 3.

Comma declarators

float a = 1, b, c = 3;

The example declares three 1-component values: a initialized to 1, b defaulted to 0, c initialized to 3. A declarator that is not a bare identifier fails with In Graph statement '{Text}': '{Declarator}' is not a valid declarator in a comma-separated declaration.

Brace initializers

A right-hand side whose trimmed text is at least two characters long, starts with { and ends with } is a brace initializer. It is re-serialised as <TargetType>( <inner> ) and evaluated as an ordinary constructor call, so it inherits every constructor rule: positional arguments only, a single scalar splats to all channels, multiple arguments must sum to exactly the target width. See Constructors.

{} is special-cased: it produces the target type's default value, exactly as if the declaration had no initializer.

Target-type resolution, in order:

Texture and Substrate targets are rejected at steps 3 and 4.

Graph = {
    float r = 1.0;
    float g = 0.5;
    float b = 0.2;
    vec3 rgb  = {r, g, b};      // -> vec3(r, g, b)
    vec4 rgba = {rgb, 1.0};     // -> vec4(rgb, 1.0), mixed-width packing
    Color = rgba.rgb;
}

Redeclaration

A declaration whose name is already bound fails with Graph variable '{Name}' is declared more than once. The lookup tries the exact spelling first, then falls back to a case-insensitive scan, so float a = 1; float A = 2; is a redeclaration error — while A and a refer to the same value everywhere else. To rebind an existing name, omit the type token and write an assignment.

Assignment

Forms 4 and 5. The target is the left side of the top-level =, taken verbatim after trimming.

<target> = <expression> ;
<target> = { <expression> , … } ;

The target is resolved in this order:

Lookup in rules 2 and 3 is case-insensitive.

Rule 4 means an undeclared name on the left of = is not an error:

Graph = {
    vec3 Base = Tint * 2.0;
    Scratch   = Base.rgb;    // legal: creates 'Scratch' as a 3-component value
    Color     = Scratch;     // 'Color' is an Outputs declaration -> coerced to its type
}

Expression statements

Form 9. A statement that is neither a declaration nor an assignment is evaluated as an expression and accepted only when it is a call:

In statement form the arguments are the declared inputs followed by one plain variable name per output, in declaration order. Statement calls are positional-only for every callee kind. Full argument rules are on Calls.

MaterialAttributes member writes

Forms 6 and 7 write one attribute of a MaterialAttributes value. The type is a struct-like Graph value with component count 0 since 1.2.5; it carries a whole material's attribute set as one connection.

Outputs = { MaterialAttributes Attrs; Base.MaterialAttributes = Attrs; }
Graph   = {
    MaterialAttributes Attrs;      // the Outputs declaration does NOT create it
    Attrs.BaseColor = Tint;
    Attrs.Roughness = {0.35};
    float Rough = Attrs.Roughness; // a read: BreakMaterialAttributes
}

Each member write chains a new SetMaterialAttributes node onto the variable's current value and rebinds the variable to it; N writes produce N nodes. Each member read creates a new BreakMaterialAttributes node — reads are not deduplicated.

Members

Member names are matched case-insensitively on both the read and the write side. Aliases are exact synonyms.

MaterialAttributes and its alias Attributes resolve as material properties but are explicitly rejected as members. Any unrecognised name fails with Unsupported MaterialAttributes member '{Member}'.

A read picks the Break output by name first — the attribute's display name is compared case-insensitively against every output on the node — and falls back to the legacy index only when no name matches.

Member write rules

Scope

There is no block scope. One value map exists per builder — one per Shader, one per generated material function — and every declaration writes into it.

Branches are executed against copies of the enclosing map, and the copies are then merged:

Synthesized statements

Every Outputs declaration of the enclosing block that carries a default value is turned into a declaration statement and prepended before the first statement of the Graph body. These statements have no source location, so their diagnostics carry no usable line number.

This is also what makes Graph = { } legal for a Shader: the initialized output declaration is the body. See Output Bindings.

Diagnostics

While the statements run, the progress text reads Building DreamShader graph nodes ({N} statements)... and Evaluating DreamShader graph statement {I} of {N}.... For bodies with more than 512 statements, only every 64th statement updates the text.

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

Example

Every statement form in one body:

ShaderFunction(Name="Functions/F_AllForms")
{
    Properties = { vec3 Tint = vec3(1.0, 0.4, 0.1); float K = 2.0; }
    Inputs     = { vec2 UV; }
    Outputs    = { MaterialAttributes Attrs; vec3 Debug; }

    Graph = {
        MaterialAttributes Attrs;              //    the Outputs declaration does not create it
        float3 c;                              // 1  declaration, no initializer
        float3 scaled = Tint * K;              // 2  declaration + expression
        vec4   packed = {scaled, 1.0};         // 3  declaration + brace initializer
        c = packed.rgb;                        // 4  assignment
        Debug = {0.0, 0.0, 0.0};               // 5  assignment + brace initializer
        Attrs.BaseColor = c;                   // 6  member write
        Attrs.Roughness = {0.35};              // 7  member write + brace initializer
        float a = 1, b, d = 3;                 // 8  comma declarators

        if (K > 1.0) {                         // 10 if / else
            Debug = c * a;
        } else {
            Debug = c * b;
        }
    }
}

Form 9, the statement-form call, is the one shape missing here; it needs a callee, and it has its own page.

See also

• Expressions and Conversions — what may appear on the right of =
• Control Flow — form 10 in full, and the merge
• Calls — form 9, out targets and argument rules
• What Graph Is Not — why return, for and += report variable-type errors