Property Types

Every declaration inside a Properties section becomes exactly one node in the generated material. Which node you get is decided by the type token you write, and nothing else: the token picks the Unreal expression class, the default-value grammar and — for a handful of types — whether the declaration can be called from Graph to wire its input pins.

There are two ways to name a type. A compact token (float, vec3, Texture2D) says what the value is and lets DreamShader choose the node. An explicit *Parameter token (TextureSampleParameter2D, ChannelMaskParameter) names the Unreal expression class directly. Reach for a compact token first; reach for an explicit one when you need a node the compact set cannot produce.

The shape of a declaration

[const] <type-token> <name> [ = <default-value> ] [ [ <metadata-entry> ; … ] ] ;

The [ … ] around <default-value> and around the metadata block is the "optional" meta-bracket; the brackets of the metadata block itself are literal punctuation. A declaration with metadata is written float A = 1.0 [Group="X"];. The metadata grammar is on Metadata and Groups; the enclosing section grammar is on Sections.

Every type token is matched case-insensitively. FLOAT3, Float3 and float3 are one token; so are texturesampleparameter2d and TextureSampleParameter2D.

The four families

A fifth form, UE.<Name>( … ) <name>;, declares an engine input node (UVs, time, vertex colour, a parameter collection lookup) as a property. It is covered under UE.* Nodes and UE.Expression.

A token that matches none of these fails with Unsupported property type '{Token}'.

Compact scalar tokens

Seven spellings, identical in every observable respect.

Scalar defaults

float A = 0.5;    float B = -2;    float C = 1e3;    float D = true;

The text is parsed as a double, with true → 1.0 and false → 0.0 accepted as case-insensitive aliases. Anything else fails with Invalid scalar default value '{Text}' for property '{Name}'.

With no = <default> nothing is written and the node keeps the engine default 0.0.

Compact vector tokens

27 spellings. Every one produces a UMaterialExpressionVectorParameter whose DefaultValue is a full FLinearColor; only the declared component count differs, and that is what decides which node output a Graph read targets. The count comes from the token's last character — 2 is two components, 4 is four, anything else is three.

vec*, ivec*, uvec* and bvec* are GLSL-flavoured spellings of float*, int*, uint* and bool*. There is no compact token for a one-component vector: float1 and half1 are scalars.

Vector defaults

<anything> ( <part> [ , <part> ] … )

With no = <default> the node keeps the engine default (1, 1, 1, 1).

Compact texture tokens

Five spellings, four distinct dimensions. Each generates a texture object parameter — the node carries an asset, it does not sample it.

Texture3D and VolumeTexture are exact synonyms. To sample one of these, feed it to a TextureSample builtin from Graph, or declare a TextureSampleParameter2D instead.

Texture defaults

Texture2D A = Path(Game, "Textures/T_X");
Texture2D B = Path("/Game/Textures/T_X");
Texture2D C = "/Game/Textures/T_X";            // bare quoted absolute path

The bare quoted form arrived in since 1.5.0. Every root spelling and both error sets are on Asset References; a failure is wrapped as Invalid texture default value '{Text}' for property '{Name}'. {Inner}.

Defaults when no asset is assigned

Dimension validation

All five compact tokens declare an explicit dimension, so the assigned asset is checked against it — Texture2D here means "not a cube, not a 2D array, not a volume". A mismatch is reported as

{Context} texture property '{Name}' expects {ExpectedType} but '{Path}' is a '{ActualClass}'.

with {Context} being Texture for a parameter and Const for a const declaration. After a successful load AutoSetSampleType() runs, so SamplerType follows the asset unless metadata overrides it.

const declarations

since 1.2.6 A const declaration emits a constant node instead of a parameter: no name in the material's parameter list, no instance override.

const float Gamma = 2.2;                       // Constant
const vec3  Sky   = vec3(0.2, 0.4, 0.9);       // Constant3Vector
const Texture2D Lut = Path(Game, "T_Lut");     // TextureObject

const is legal only with the 39 compact tokens. Combined with any *Parameter token or any UE.* declaration it is rejected with Const property '{Name}' must use a plain scalar, vector, or texture type instead of a parameter node or UE builtin declaration.

A const declaration still accepts a metadata block — [Desc="…"] on a Constant node works — and a const vector read from Graph always targets output 0, not the named RG / RGB / RGBA output a parameter read would use.

Parameter node tokens

22 tokens that name an Unreal parameter expression class directly. ScalarParameter, VectorParameter and TextureObjectParameter take dedicated construction paths; every other token resolves its class by name, trying <Token>, U<Token>, MaterialExpression<Token> and UMaterialExpression<Token> in that order against every non-abstract UMaterialExpression subclass, case-insensitively. The set is closed — exactly these 22.

Type is the DreamShader property type, not the Unreal pin type. Texture means "asset-valued": the node carries an asset and produces no numeric output.

SpriteTextureSampler lives in the Paper2D plugin. With Paper2D disabled the class cannot be resolved and generation fails with Could not resolve MaterialExpression class for parameter type 'SpriteTextureSampler'.

Which default parser a token uses

The = <default> branch is chosen by the token family, not by what the generated node can actually store.

A default value is optional for every one of the 22 tokens. What happens to the value you do write:

If none of those six asset slots exists on the class, generation fails with '{Class}' does not expose a texture/asset property for property '{Name}'.

A sampler parameter with no texture still compiles: SetDefaultTexture() is called for UMaterialExpressionTextureSampleParameter subclasses, then AutoSetSampleType() runs. That rescue does not apply to the runtime-virtual-texture, sparse-volume, font or curve-atlas nodes — those still need their asset bound.

Dimension: inferred, and mostly unchecked

The eight texture-sample tokens infer a dimension from their spelling by substring test, in order: Cube → TextureCube, then Array → Texture2DArray, then Volume → VolumeTexture, otherwise Texture2D. (TextureSampleParameterCubeArray contains both Cube and Array; Cube wins. It has no observable effect — the generated class is still the correct cube-array class.)

The three texture-object tokens deliberately declare no dimension: it comes from the assigned asset at generation time.

Reading a property in Graph

A bare identifier reads the property's value. The declared component count picks which node output the read targets:

So vec2 P reads RG while VectorParameter P reads RGBA. Reads are lazy and cached: the node is created on first reference — declaration order does not constrain reads — and every later reference returns the same node. See Calls and Expressions and Conversions.

The pin call form

since 1.4.1 Some parameters can be called to wire their input pins:

vec4 S = BaseTex(Coordinates = UV);
vec4 M = Keep(Input = S);

The node is materialised exactly as a bare read would materialise it — same cache — and each named argument is matched against the node's input pins. Matching trims and lower-cases both sides. There is no positional variant: every argument must be named, and argument values must be numeric.

Exactly ten tokens are routed to the pin-wiring evaluator:

ChannelMaskParameter                  TextureSampleParameterCubeArray
StaticComponentMaskParameter          TextureSampleParameterVolume
TextureSampleParameter2D              TextureSampleParameterSubUV
TextureSampleParameter2DArray         RuntimeVirtualTextureSampleParameter
TextureSampleParameterCube            SparseVolumeTextureSampleParameter

Everything else — every compact token and the remaining eleven *Parameter tokens — is not routed there at all; a call on one of them falls through to the function-call dispatcher and fails as an unknown function.

Which pins are reachable

Pin names come from the engine node at generation time, so what is reachable depends on the node and on metadata applied before the call — metadata is applied when the node is created, which is before any pin is wired.

StaticSwitchParameter

A static switch has its own call form and cannot be read as a value:

vec3 C = UseDetail(True = DetailColor, False = BaseColor);
vec3 D = UseDetail(A = DetailColor, B = BaseColor);
vec3 E = UseDetail(DetailColor, BaseColor);          // positional, in that order

The true branch is taken from True=, else A=, else the first positional argument; the false branch from False=, else B=, else the second. Both are required. Neither branch may be a texture object or a Substrate value, the two may not mix MaterialAttributes with numeric, and both must have the same component count. A bare UseDetail — or UseDetail.r — fails with Unknown Graph identifier 'UseDetail'.

Tokens that are not valid in Properties

These are real DreamShaderLang type tokens elsewhere. In a Properties declaration each falls through to Unsupported property type '{Token}'.

The full cross-context matrix is on Types and Values.

Naming rules

• A property name is only required to be non-empty. It is never validated as an identifier, so float 1Bad = 0; parses — and is then unreachable from Graph, where names are looked up as identifiers.
• Property names must be unique ignoring case within a Shader. Inside a material function a property may not collide with an input name either.
• [ParameterName="…"] changes the name the material exposes to instances and Blueprints; the declared identifier stays the name Graph uses.

Diagnostics

The complete list, by stage, is in Diagnostics.

Example

Shader(Name="Docs/M_ParameterNodes")
{
    Properties = {
        const float Gamma = 2.2;                       // Constant

        Group("Surface") {
            TextureSampleParameter2D BaseTex = Path(Game, "Textures/T_White") [
                SamplerType   = "LinearColor";
                SamplerSource = "FromTextureAsset";
                MipValueMode  = "None";
            ];
            ScalarParameter Roughness = 0.55 [Slider(0, 1)];
            VectorParameter Tint      = float4(1.0, 0.8, 0.6, 1.0);
        }

        Group("Masks") {
            ChannelMaskParameter         Pick = float4(1, 0, 0, 0) [MaskChannel = "Red"];
            StaticComponentMaskParameter Keep = float4(1, 1, 0, 0);
        }

        StaticSwitchParameter UseDetail = true [Group="Switches"];

        UE.TexCoord(Index = 0) UV;
    }

    Settings = { Domain = "Surface"; ShadingModel = "DefaultLit"; BlendMode = "Opaque"; }

    Outputs = {
        vec3  Color;
        float Rough;

        Base.BaseColor = Color;
        Base.Roughness = Rough;
    }

    Graph = {
        vec4  Sample = BaseTex(Coordinates = UV);
        vec4  Masked = Keep(Input = Sample);
        float Chan   = Pick(Input = Sample);

        Color = UseDetail(True = Masked.rgb, False = Tint.rgb) * Gamma;
        Rough = Roughness * Chan;
    }
}

Generated nodes:

Constant(2.2)                 Gamma
TextureSampleParameter2D      BaseTex    Group="Surface" SortPriority=0  SamplerType=LinearColor
ScalarParameter               Roughness  Group="Surface" SortPriority=10 SliderMin=0 SliderMax=1
VectorParameter               Tint       Group="Surface" SortPriority=20
ChannelMaskParameter          Pick       Group="Masks"   SortPriority=30 MaskChannel=Red
StaticComponentMaskParameter  Keep       Group="Masks"   SortPriority=40
StaticSwitchParameter         UseDetail  Group="Switches"
TextureCoordinate             UV         CoordinateIndex=0

Next

• Metadata and Groups — the [ … ] block, Slider(…), groups and sort order
• Asset References — every Path(…) root spelling and its errors
• UE.* Nodes — declaring an engine input node as a property
• Calls — the general call grammar these forms belong to