Control Flow

if / else is the only control-flow statement in the Graph language, and it is not a jump. Both branches are executed at generation time, every node in both of them ends up in the finished material, and a UMaterialExpressionIf picks between the two results per pixel.

Synopsis

if ( <condition> )
{
    <graph-statement> …
}
[ else
{
    <graph-statement> …
} ]

<condition> := <expression> [ { >= | <= | == | != | > | < } <expression> ]

else if chains are legal and are captured as raw text, then re-parsed as a nested if inside the else body — an else if chain is a tree of nested statements, not a flat list.

Requirements

The condition

The condition text is split textually, before the expression parser runs. Comparison operators are not part of the expression grammar — this is the only place any of them is accepted.

How the split is performed:

1. The text is scanned left to right at nesting depth 0. ( ), { }, [ ] depth and string literals are tracked and skipped.
2. At each position the operators are probed in the fixed order >=, <=, ==, !=, >, <. The first position that matches wins, and a two-character operator is always probed before the one-character operator that prefixes it, so a >= b splits on >= and never on >.
3. If a match is found but either side is empty after trimming, the split is discarded and the whole text becomes a truthy condition instead.
4. With no operator match, the whole text is the left operand and the operator is truthy.
5. Each side goes to the ordinary expression parser. A failure is reported as In Graph if condition '{Condition}': {Error}.

Both operands must evaluate to a scalar — one component — and must not be a texture object, a MaterialAttributes value or a Substrate value.

Truthy semantics

// Written — the then-branch runs for -1.0 as well as for 1.0.
if (Height) { Color = Hot; } else { Color = Cold; }

// What that actually compiles to:
if (Height != 0) { Color = Hot; } else { Color = Cold; }

// If the sign is what you meant, say so:
if (Height > 0) { Color = Hot; } else { Color = Cold; }

The right operand of a truthy condition is a synthesized Constant node holding 0.

&& and || are silently dropped

// Written — compiles, but the second test is discarded.
if (Mask > 0.5 && Alpha > 0.5) { Color = Hot; } else { Color = Cold; }

// Equivalent, and what the compiler actually built:
if (Mask > 0.5) { Color = Hot; } else { Color = Cold; }

// Write nested ifs instead:
if (Mask > 0.5) {
    if (Alpha > 0.5) { Color = Hot; } else { Color = Cold; }
} else {
    Color = Cold;
}

Node wiring

One UMaterialExpressionIf node is created per merged variable. A receives the condition's left operand, B the right operand (or the synthesized zero), and the three result pins are wired from the branch values:

The result takes its component count and its MaterialAttributes flag from the then branch. It is never a texture object and never a Substrate value.

Both branches are always built

There is no dead-code elimination and no build-time constant folding of the condition. Executing an if does exactly this, in order:

1. Copy the current variable map; run every then-statement against the copy.
2. Copy the current variable map again; run every else-statement against that copy.
3. Restore the enclosing map and merge.

What that means in practice:

• Every node in both branches exists in the generated material. A branch that is never taken at runtime still costs shader instructions. if is a select, not a jump.
• An error inside either branch fails the build, even a branch that a constant condition could never reach. Body errors are wrapped as In Graph if body: {Error} / In Graph else body: {Error}.
• A variable declared inside a branch does not stay local — it participates in the merge.
• Node reuse is not scoped to a branch. A subexpression first built in the then-branch is reused verbatim in the else-branch and after the merge.
• The condition is evaluated once per merged variable. The operands go through the reuse cache, so there is one set of condition nodes — but N If nodes for N merged variables.

// Two ScalarParameter nodes named 'Threshold'.
if (u > 0.5) { Color = Lit.rgb * Threshold; } else { Color = Dark.rgb * Threshold; }

// One.
float T = Threshold;
if (u > 0.5) { Color = Lit.rgb * T; } else { Color = Dark.rgb * T; }

The merge

A name is a branch output when it is present in a branch's map and is either absent from the enclosing map or bound to a different value there. Two values count as the same only when the node, output index, component count, all five channel-mask fields, the texture flag, the texture type, the MaterialAttributes flag and the Substrate flag all match.

// Fails: 'Blend' is float3 in one branch and float in the other.
if (Mask > 0.5) { float3 Blend = float3(1.0, 0.0, 0.0); Color = Blend; }
else            { float  Blend = 0.25;                  Color = float3(Blend, Blend, Blend); }

// Works: one declaration, one shape, assigned in both branches.
float3 Blend = float3(0.0, 0.0, 0.0);
if (Mask > 0.5) { Blend = float3(1.0, 0.0, 0.0); }
else            { Blend = float3(0.25, 0.25, 0.25); }
Color = Blend;

What cannot be selected

To branch on textures, sample both and select the resulting numeric values, or move the choice into a StaticSwitchParameter on the sampled results. See Calls.

Diagnostics

Example

Shader(Name="Docs/M_IfElse")
{
    Properties {
        float Mask = 0.6;
        vec3  Tint = vec3(1.0, 0.2, 0.2);
    }

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

    Outputs {
        vec3 Color;
        Base.EmissiveColor = Color;
    }

    Graph {
        if (Mask > 0.5) {
            Color = Tint;
        } else if (Mask > 0.25) {
            Color = Tint * 0.5;
        } else {
            Color = vec3(0.0, 0.0, 0.0);
        }
    }
}

VectorParameter  Tint
ScalarParameter  Mask
Constant         0.5                 (shared)
Constant         0.25
Multiply         Tint * 0.5
Constant3Vector  (0,0,0)             (folded literal)
If               A=Mask B=0.25  ->   inner else-if merge of 'Color'
If               A=Mask B=0.5   ->   outer merge of 'Color'

Both If nodes exist because the else if is a nested if, and every branch's nodes are present in the material regardless of the runtime value of Mask.

See also

• Statements — the forms legal inside a branch, and declaration scope
• Expressions and Conversions — the grammar the operands are parsed with, and the coercion applied at the merge
• Calls — StaticSwitchParameter, the compile-time alternative to if
• What Graph Is Not — loops, switch, ?: and the silent-truncation catalogue