Unsupported constructs

DreamShader » Graph » Unsupported constructs

Every HLSL and GLSL construct that a Graph block does not implement, the code the compiler reports for it, and what to write instead.

A Graph block is a node-graph builder, not a shader compiler. It has a fixed set of statement forms, four arithmetic operators and no control flow other than if. Anything else is refused with a diagnostic code. Nothing is compiled into something smaller than what was written (since 2.0.0): the 1.x generator silently dropped the rest of an expression at the first operator it did not know (a % b built a), and every such construct is now an error whose message says what 1.x did.

To write loops, ?:, && or bitwise operators, move the code into a Function or migrate the file to .dss with dsc migrate, where they exist.

How a construct is refused

The legacy front end reads a Graph body with the 2.0 statement and expression parser, whose grammar is a superset of the 1.x one, and then refuses what 1.x did not have (since 2.0.0):

Every diagnostic carries the line and column of the construct. A stage reports all of its errors, and a stage with errors stops the build before the next one.

Operators 1.x truncated

Each of these was accepted by 1.x and built only the part before the operator, without a message. (since 2.0.0) each is an error.

// Refused (DSH2201); 1.x built this as UE.Time().
float Wave = UE.Time() % 1.0;

// Correct:
float Wave = fmod(UE.Time(), 1.0);

// Refused (DSH2210); 1.x built this as if (Color.r > 0.5).
if (Color.r > 0.5 && Color.g > 0.5) { Out = One; } else { Out = Zero; }

// Correct:
if (Color.r > 0.5) {
    if (Color.g > 0.5) { Out = One; } else { Out = Zero; }
} else {
    Out = Zero;
}

The restriction pass reports a refused construct once and does not look inside it, so a % b % c is one diagnostic; a % b + c % d is two.

Statement-level constructs

Graph bodies are read as statements, not as text split at ;, so a braced construct followed by more code no longer swallows that code into one statement (since 2.0.0).

Expression-level constructs

Compound assignment and increment

+= -= *= /= %=, the bitwise compound forms, ++ and -- are not 1.x operators.

(since 2.0.0) the spacing no longer matters. 1.x read a += b; as a declaration of a variable named + of type a, and a+=b; as an assignment to a brand-new variable named a+, leaving a unchanged without a message; both are DSH2205 now. Write the expansion: a = a + b;.

// Refused (DSH2205).
Sum+=Tint;

// Correct:
Sum = Sum + Tint;

Wrong-case keywords

if and else are keywords and are matched case-sensitively, as are for, while, return, struct and the other HLSL keywords. A mis-cased spelling is a name.

Type tokens, constructor names and true / false are matched in any case. Other names are looked up exactly first and then ignoring case, with a warning (DSH5275, DSH5276 for engine names); see Name resolution.

Features that simply do not exist

Diagnostics

The complete list, with every message, lives in the diagnostics index.

Example

A GLSL-shaped attempt and its DreamShaderLang equivalent.

// Refused.
Graph {
    vec2  uv    = UE.TexCoord(Index = 0);
    float t     = UE.Time() % 4.0;                 // DSH2201
    float mask  = uv.x > 0.5 && uv.y > 0.5;        // DSH2200
    vec3  col   = mask ? Hot : Cold;               // DSH2200
    col        *= Gain;                            // DSH2205
    Color = col;
}

// Correct.
Graph {
    vec2  uv = UE.TexCoord(Index = 0);
    float t  = fmod(UE.Time(), 4.0);

    vec3 col;
    if (uv.x > 0.5) {
        if (uv.y > 0.5) { col = Hot; } else { col = Cold; }
    } else {
        col = Cold;
    }

    Color = col * Gain;
}

Anything genuinely imperative — a loop, a bitwise mask, a switch — belongs in a Function, whose body is real HLSL and is compiled into a Custom node:

Function SelfContained float Ring(in float2 uv, in float count)
{
    float acc = 0.0;
    for (int i = 0; i < 4; ++i)
    {
        acc += sin(uv.x * count * (i + 1));
    }
    return acc * 0.25;
}

Graph {
    float r = Ring(uv, 8.0);
}

See also

• Statements — the statement forms that are supported
• Expressions — the four operators that exist, and their precedence
• if / else — the only control flow, and the condition operators
• Literals — accepted numeric forms, suffixes, and what is not a literal
• Constructors — the replacement for casts and matrix construction
• Swizzle — the replacement for indexing
• Calls — moving imperative code into a callable function
• Function — HLSL bodies, where loops and bitwise operators are legal
• GraphFunction — HLSL bodies with UE.* nodes hoisted into pins
• Math builtins — fmod, min, max, clamp, lerp
• Name resolution — the case-sensitivity matrix
• dsc migrate — rewrite a 1.x file as .dss, where loops and ?: exist
• Diagnostics index — every code, by stage