UE.* Nodes

The UE. namespace is how DreamShaderLang creates Unreal material nodes. Twenty-seven names in it are registered builtins: DreamShader implements each one itself, mapping it to a single UMaterialExpression class with a fixed argument set. Three more names — UE.StaticSwitchParameter, UE.CollectionParam and UE.SceneTexture — are special-cased ahead of that table.

Everything else in the namespace falls through to the generic reflected path, UE.Expression, where UE.<Name> simply means "create UMaterialExpression<Name>". A name that is not on this page is therefore not an error — it is a different code path with different rules.

Both the namespace prefix and the builtin name are matched case-insensitively: ue.texcoord() is UE.TexCoord(). Argument names are matched case-insensitively after trimming, but are otherwise exact — Un_Mirror_U is not UnMirrorU.

Two rules to read before the catalogue

Synopsis

// expression form, inside Graph
UE.<Name> ( [ <argument> [ , <argument> ] … ] )

<argument> := <arg-name> = <expression>

// declaration form, inside Properties
UE.<Name> [ ( <key> = <value> [ , <key> = <value> ] … ) ] <property-name> ;

The roster

All 27 registered builtins, in registration order. Class names are written without their UMaterialExpression prefix.

Every width above is authoritative, which makes any registered builtin a valid widening partner in a mixed-width binary operator. See Expressions and conversions. None of these builtins produces a texture object, a MaterialAttributes value or a Substrate value.

Aliases

Four names in the roster are second spellings of an entry that is already there. Both spellings create the same node class.

Builtins that take arguments

UE.TexCoord

float2 uv    = UE.TexCoord(Index = 0);
float2 tiled = UE.TexCoord(Index = 0, UTiling = 2.0, VTiling = 2.0);

CoordinateIndex is not an accepted spelling here — it is accepted only by the declaration form. A negative Index is accepted without a diagnostic in the expression form.

UE.Time

float t      = UE.Time();
float looped = UE.Time(Period = 2.0, IgnorePause = true);

Supplying Period also turns the node's period override on. No range check is applied in a Graph: a negative Period is written through unchanged. The declaration form rejects it.

UE.Panner

float2 panned = UE.Panner(Coordinate = UE.TexCoord(Index = 0),
                          Time       = UE.Time(),
                          SpeedX     = 0.1,
                          SpeedY     = 0.0);

ConstCoordinate is not accepted in the expression form. The declaration form accepts it, and the generic path can reach it as UE.Expression(Class = "Panner", OutputType = "float2", ConstCoordinate = 1).

UE.TransformVector

Transforms a direction between bases. Rotation only — translation is not applied, which is what makes it the wrong choice for a point.

vec3 worldNormal = UE.TransformVector(LocalNormal, Source = "Tangent", Destination = "World");

Both basis arguments accept the same nine spellings, resolving to six engine values. Every spelling works on UE 5.3 – 5.8, and no spelling is accepted by one side and rejected by the other.

Basis names are matched case-insensitively after trimming, so "world", "World" and " WORLD " are one token. Spaces, underscores and hyphens are not stripped: "absolute world" and "absolute_world" do not resolve — write "AbsoluteWorld". A quoted string and a bare identifier are equivalent, so Source = World and Source = "World" are the same.

Either token failing to resolve produces the single message UE.TransformVector Source/Destination is invalid. — it does not say which one.

UE.TransformPosition

Transforms a point between bases, applying translation.

vec3 viewP = UE.TransformPosition(UE.WorldPosition(),
                                  Source      = "World",
                                  Destination = "TranslatedWorld");

Note that the default Source differs from UE.TransformVector: it is "Local" here and "Tangent" there.

One resolver serves both Source and Destination, so the accepted set is identical for the two arguments. Thirteen spellings resolve to eight engine values.

Builtins that take no arguments

Twenty-two of the twenty-seven take nothing at all. Each creates its node with every input pin left unconnected.

Position and geometry

For the other shader-offset modes of WorldPosition, use the generic path: UE.Expression(Class = "WorldPosition", OutputType = "float3", WorldPositionShaderOffset = …).

Vectors and normals

Screen and scene

To wire a UV into a scene depth read, use the generic path: UE.Expression(Class = "SceneDepth", OutputType = "float1", Input = <uv>).

Per-vertex and per-instance data

Special-cased builtins

These three names are resolved before the registered table and do not follow its rules.

UE.StaticSwitchParameter

Creates a static switch that shows up in the material instance editor, so an artist can flip a branch without touching the source.

vec3 color = UE.StaticSwitchParameter(Name        = "UseDetail",
                                      True        = detailColor,
                                      False       = baseColor,
                                      Default     = true,
                                      Group       = "Switches",
                                      Description = "Choose the detail branch");

The output takes its component count and its MaterialAttributes flag from the True branch. Both branches must agree: neither may be a texture object or a Substrate value, they may not mix MaterialAttributes with numeric values, and their component counts must be equal.

The parameter is registered on the generated material with an editor-only static-switch value. Inside a material function nothing is registered. A node already registered under the same property name is reused rather than duplicated.

UE.CollectionParam

Reads a scalar or vector parameter out of a UMaterialParameterCollection. UE.CollectionParameter is an accepted second spelling.

float wind = UE.CollectionParam(Collection = Path(Game, "Collections/MPC_Wind"),
                                Parameter  = "WindStrength");

The collection is loaded at generation time and the parameter is looked up by name in it. The output width follows what it finds:

UE.CollectionParam is also the only builtin placed at a negative canvas X (-520); the rest of the registered builtins land at 520 and the declaration form at -800.

For Path(…) grammar and its accepted roots, see Asset references.

UE.SceneTexture

Pure sugar, resolved before every other UE. name.

float4 scene = UE.SceneTexture(Id = "PostProcessInput0");

It rewrites the call to

UE.Expression(Class = "SceneTexture", OutputType = "float4", SceneTextureId = <Id>)

and evaluates that, so the node is UMaterialExpressionSceneTexture with a float4 output and every generic-path rule applies from there — including node reuse.

The call must have exactly one argument and it must be named Id; anything else fails with UE.SceneTexture expects exactly Id="..." (e.g. Id="PostProcessInput0").

The Id text goes through the reflected enum writer, which accepts the entry name with or without its enum prefix, the fully qualified name, and the display name — ignoring case and ignoring the space, _, -, :, . and / characters. All of "PostProcessInput0", "PPI_PostProcessInput0" and "ppi postprocessinput0" select the same value.

Properties declaration form

UE.<Name>(…) may also stand where a type token would, inside a Properties section. The node is created once at generation time and bound to a property name the Graph then reads.

Properties {
    UE.TexCoord(Index = 0) UV;
    UE.CollectionParam(Collection = Path(Game, "MPC_Weather"), Parameter = "Wind") Wind;
}

Graph {
    Color = vec3(UV.x, UV.y, Wind);
}

Inline defaults are the mistake to watch for. Put arguments inside the parentheses:

// correct
UE.TexCoord(Index = 0) UV;

// error: UE builtin property 'UV' does not support inline defaults.
UE.TexCoord UV = 0;

Recognized names

An argument outside its row is rejected with UE.{Name} for property '{Property}' does not support argument '{Argument}'.

ShaderOffsets vocabulary — lower-cased with spaces removed:

Origin vocabulary — lower-cased with spaces removed:

Declared output width

The declared width comes from the first of these that resolves:

1. an explicit OutputType or ResultType argument, from the reduced token set;
2. the parser's own name table, below;
3. CollectionParam / CollectionParameter, which declare a 1-component scalar;
4. otherwise the declaration is rejected.

A const qualifier is rejected on a UE.* property with Const property '{Name}' must use a plain scalar, vector, or texture type instead of a parameter node or UE builtin declaration.

Notes worth knowing

• A UE.* call may be swizzled directly — UE.TexCoord(Index = 0).x is an ordinary postfix chain. See Expressions and conversions.
• UE.* names are resolved before user declarations, so a property or function named TexCoord does not shadow UE.TexCoord. Nothing stops such a property from existing and being read as a bare identifier, though. See Calls.
• A registered builtin never accepts OutputType, Class, Output, OutputName or OutputIndex. Those are read only on the generic path; on a registered builtin they are silently discarded like any other unknown name.
• Inside a GraphFunction, UE.* calls are lifted out of the HLSL body and become generated input pins on the emitted Custom node.

Diagnostics

{Function} is the builtin name as the author spelled it, casing preserved — with one exception, Failed to create UE.{Function}., which prints the registered spelling instead.

Every generation-time message from the declaration form is additionally wrapped as UE.{Function} for property '{Property}': {Message}. The complete list lives in the diagnostics index.

Example

Shader(Name="Docs/M_UEBuiltins")
{
    Properties {
        vec3 Tint = vec3(1.0, 0.6, 0.2);
        UE.TexCoord(Index = 0) UV0;
    }

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

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

    Graph {
        float2 uv   = UE.Panner(Coordinate = UV0, Time = UE.Time(), SpeedX = 0.1, SpeedY = 0.0);
        float3 wp   = UE.TranslatedWorldPosition();
        float3 nrm  = UE.TransformVector(UE.VertexNormalWS(), Source = "World", Destination = "Tangent");
        float  fade = UE.PerInstanceFadeAmount();
        float4 vcol = UE.VertexColor();

        Color = (vec3(uv.x, uv.y, wp.z) + nrm) * Tint * vcol.rgb * fade;
    }
}

Generated nodes:

TextureCoordinate  (Index 0)                  <- UV0        (Properties, X = -800)
Panner             (Coordinate, Time, SpeedX) <- uv         (X = 520)
Time                                          <- Panner.Time
WorldPosition      (camera-relative)          <- wp
VertexNormalWS                                -> Transform
Transform          (World -> Tangent)         <- nrm
PerInstanceFadeAmount                         <- fade
VertexColor                                   <- vcol

Where to next