GLSL Overview

GLSL is what most shader examples on the internet are written in. DreamShaderLang is not a GLSL compiler and never emits GLSL — the target is Unreal's material graph and HLSL. But GLSL spellings are deliberately accommodated, in two quite different ways, and telling the two apart is the whole point of this page.

// GLSL
vec3 applyTint(vec3 color, vec3 tint)
{
    return color * tint;
}

// DreamShaderLang — the same helper. vec3 survives in the declaration,
// and becomes float3 in the generated HLSL.
Function vec3 ApplyTint(in vec3 color, in vec3 tint) {
    return color * tint;
}

GLSL type aliases

These are real tokens, accepted everywhere the corresponding float / int / uint / bool spelling is accepted.

Because int, uint, bool and half all collapse to the same float component counts, choosing between int3, ivec3, bool3 and float3 is a documentation decision, not a semantic one. The single observable difference is the integer marker set by an integer constructor call in a Graph block, which exists solely to reject integer division. See Types and Values.

Rewrites inside function bodies

A Function / GraphFunction signature runs every type token through a normalizer, and the body runs every identifier through a superset of the same map. Both match on the lower-cased whole identifier, so the rewrite is case-insensitive.

15 signature aliases; 18 body aliases. The rewrite is comment- and string-aware, and it applies to Function and GraphFunction bodies only — a Graph block, a Shader body and a ShaderFunction body are not normalized.

Note that mat2 / mat3 / mat4 rewrite cleanly but resolve to types the language does not support. The declaration parses and the call fails — … input 'basis' uses unsupported type 'float3x3'. See Matrices.

GLSL function names in a Graph block

Inside a Graph block nothing is rewritten, so the GLSL spellings have to be real builtins — and three of them are:

The complete builtin catalogue is Math Builtins.

Constructors and swizzle

Both survive the trip, with GLSL spelling intact.

Graph = {
    vec3  color = vec3(1.0, 0.2, 0.1);
    float r     = color.r;
    vec2  rg    = color.rg;
    vec3  bgr   = color.bgr;
}

• Constructor names follow the type tokens, so vec2(…), vec3(…), vec4(…), ivec3(…) and so on all work in a Graph block.
• Swizzles accept between one and four channel characters, from either the xyzw or the rgba set, matched case-insensitively. Reordering and repeating are both allowed. There is no stpq set and no uv set — .uv fails.
• A swizzle can only narrow or rearrange. Roughness.yz on a scalar is a hard error, not a broadcast: Swizzle 'yz' is invalid for a value with 1 components. Repeat channel 0 (.xx) or use a constructor instead.

Details: Expressions and Conversions.

What has no equivalent

Porting a snippet

A typical GLSL fragment, and the two ways to land it.

float ring(vec2 uv, float t)
{
    vec2  p = uv - 0.5;
    float d = length(p);
    return fract(sin(t) * 0.5 + d * 4.0);
}

As a Function, where the body is HLSL and the aliases are rewritten for you:

Function float Ring(in vec2 uv, in float t)
{
    vec2  p = uv - 0.5;          // vec2 -> float2 on emission
    float d = length(p);         // HLSL intrinsic, fine inside a body
    return fract(sin(t) * 0.5 + d * 4.0);   // fract -> frac
}

As Graph statements, where nothing is rewritten and length does not exist as a builtin:

Graph = {
    vec2  uv = UE.TexCoord(Index = 0);
    vec2  p  = uv - 0.5;
    float d  = sqrt(dot(p, p));                    // length, spelled out
    float r  = fract(sin(UE.Time()) * 0.5 + d * 4.0);
}

The Function version is shorter; the Graph version produces inspectable material nodes that can be wired to parameters. Pick per case — see Functions.

Common GLSL keywords

For reference. Nothing in this table is part of the DreamShaderLang grammar except where noted above.

Where to next