Metadata and Groups

A declaration can carry a trailing [ … ] block: a list of Key = Value entries that set the generated node's organization fields and — for any key the parser does not recognize — write directly to a reflected UPROPERTY of that node's class.

That last part is what makes the block useful. Only five entry forms are special-cased; everything else is looked up on the Unreal class by reflection, so any property the engine exposes on the node you generated is reachable from source.

Writing a block

<declaration> [ <entry> ; <entry> ; … ] ;
<declaration> [ <entry> , <entry> , … ] ;

<entry> := <key> = <value>
         | Slider( <min> , <max> )

Every [, ], ;, ,, = and ( ) above is literal punctuation. ; and , may be mixed in one block, and a trailing separator before ] is accepted. Slider(…) is the only entry form without an =.

ScalarParameter Roughness = 0.5 [Group="Surface"; Slider(0, 1); Desc="Micro-surface roughness"];

Semicolon-separated entries arrived in since 1.2.4; the block itself in since 1.2.3.

Recognized keys

All key comparisons are case-insensitive. Every entry — including the recognized ones — is also stored under its lower-cased key and pushed through the reflected-property writer, so the recognized keys are the ones with an extra typed effect, not a separate namespace.

SortPriority defaults to 32 when nothing sets it, matching Unreal's own node default.

Slider(min, max)

ScalarParameter Roughness = 0.5 [Slider(0, 1)];

Matched case-insensitively, must end with ), and the inner text must split on a top-level , into exactly two numeric values. Both are written as reflected SliderMin / SliderMax, so it is exactly equivalent to [SliderMin = 0; SliderMax = 1] — and combining the two forms is a duplicate.

SliderMin / SliderMax exist on UMaterialExpressionScalarParameter. On a class without them the entry fails as an unreflected property.

ParameterName

ScalarParameter Rough [ParameterName = "Surface Roughness"];

The declared identifier stays the name Graph uses; ParameterName changes only the name the material exposes to instances and Blueprints. An empty value falls back to the declared name.

Alias rewriting and auto-injection

Before anything is written, the entry list is completed and its keys are rewritten:

Injection in steps 1–3 is what applies a value that came from somewhere other than this block — most often the enclosing Group("Name") { … } scope.

Reflected property passthrough

Any key that is not Slider(…) is resolved to an FProperty on the generated node's class:

1. the key is trimmed, lower-cased and compared against each UPROPERTY name, case-insensitively;
2. if that fails, a second pass strips a leading b from every FBoolProperty name and compares again.

So [FractionalPart = true] binds bFractionalPart, and [UseCustomPrimitiveData = true] binds bUseCustomPrimitiveData. Writing the b explicitly also works.

Value grammar by property type

Enum literals

An enum value is normalized by trimming, lower-casing and then removing every space, _, -, :, . and /. Each enumerator that is not tagged UMETA(Hidden) is tried against four spellings:

Because of the normalization, "LinearColor", "linear color", "linear-color", "SAMPLERTYPE_LinearColor" and "linear.color" all select the same value.

Object properties

An object-valued UPROPERTY takes an asset reference resolved by the metadata resolver described on Asset References.

Organization fields that are not reflected

Group, SortPriority and Desc exist on UMaterialExpressionParameter subclasses — but not every parameter node is one. UMaterialExpressionDynamicParameter is not. When one of those three fields is missing from the class it is skipped with a warning, not an error:

'{Class}' does not expose the '{Field}' organization field; ignoring it for this parameter.

Any other unresolved key is a hard error:

Metadata property '{Key}' is not a reflected property on '{Class}'.

Group(…) scopes and the SortPriority counter

since 1.5.0 A Group("Name") { … } scope inside a Properties section stamps its members. How it interacts with an explicit entry:

The counter starts at 0 and steps by 10. It is shared across every scope in the block, not reset per group:

Properties {
    Group("Surface") {
        ScalarParameter A = 0.5;                   // SortPriority = 0
        VectorParameter B = float4(1, 1, 1, 1);    // SortPriority = 10
    }
    Group("Detail") {
        ScalarParameter C = 1.0 [SortPriority=99]; // 99 — does not consume a slot
        ScalarParameter D = 2.0;                   // SortPriority = 20
    }
    ScalarParameter Loose = 3.0;                   // no group, no auto sort
}

Texture keys

The keys you will write most often are reflected ones on a texture node. They have no dedicated code path — SamplerType is an ordinary reflected key that happens to land on a TEnumAsByte<EMaterialSamplerType> UPROPERTY — but they are worth knowing by name.

MipValueMode is the one key that changes the node's pin set, and therefore what the call form can wire.

SamplerType values

17 enumerators. All four spellings of a row select it, and the comparison ignores case and strips , _, -, :, . and /.

There is no virtual counterpart for DistanceFieldFont or External.

SamplerSource values

SSM_TerrainWeightmapGroupSettings is tagged UMETA(Hidden) and is therefore not selectable. Because Shared: Wrap normalizes to sharedwrap, both [SamplerSource="Shared: Wrap"] and [SamplerSource="SharedWrap"] select the same value.

Application order

Because metadata is applied last, an explicit [SamplerType=…] always wins over the inferred value. Omitting the key means the value follows the asset — and changes if the asset is later recompressed. The decompiler therefore emits SamplerType and the texture-sample keys explicitly on every export, so a decompile → recompile round trip is stable.

Where else the block is accepted

• On Inputs / Outputs / Results typed parameters of a material function, but there only Description / Desc / Tooltip and SortPriority / Sort have any effect. Group is parsed and retained but never applied — Unreal's function input/output nodes have no group field — and every other key is ignored rather than reflected. An input's SortPriority defaults to its declaration index.
• Not on a Shader's Outputs statements, nor on Settings, Options or Layout entries.
• On a const declaration: [Desc="…"] on a Constant node works.

Diagnostics

Parse time

Generation time

Example

Shader(Name="Docs/M_Metadata")
{
    Properties = {
        Group("11 - Specular") {
            TextureSampleParameter2D MetallicMap = Path(Game, "Textures/T_White_Linear") [
                SamplerType          = "LinearColor";
                SamplerSource        = "FromTextureAsset";
                MipValueMode         = "None";
                AutomaticViewMipBias = true;
                ConstCoordinate      = 0;
                ConstMipValue        = -1;
                Description          = "Packed metallic / roughness";
            ];

            ScalarParameter Metallic = 0.0 [Slider(0, 1); SortPriority = 51];
        }

        VectorParameter Tint = float4(1, 1, 1, 1) [
            Category               = "Look",
            Tooltip                = "Multiplied over base colour",
            UseCustomPrimitiveData = false,
            ParameterName          = "Base Tint"
        ];
    }

    Settings = { Domain = "Surface"; ShadingModel = "DefaultLit"; BlendMode = "Opaque"; }
    Outputs  = { vec3 Color; float M; Base.BaseColor = Color; Base.Metallic = M; }

    Graph = {
        vec4 S = MetallicMap(Coordinates = UE.TexCoord(Index = 0));
        Color = S.rgb * Tint.rgb;
        M     = S.b * Metallic;
    }
}

Applied properties:

MetallicMap  Group="11 - Specular"  SortPriority=0   Desc="Packed metallic / roughness"
             SamplerType=SAMPLERTYPE_LinearColor     SamplerSource=SSM_FromTextureAsset
             MipValueMode=TMVM_None  bAutomaticViewMipBias=true
             ConstCoordinate=0       ConstMipValue=-1
Metallic     Group="11 - Specular"  SortPriority=51  SliderMin=0  SliderMax=1
Tint         Group="Look"           Desc="Multiplied over base colour"
             bUseCustomPrimitiveData=false           ParameterName="Base Tint"

Metallic takes SortPriority = 51 from its own entry, so it does not consume a counter slot; MetallicMap took slot 0.

Next

• Property Types — the tokens a metadata block can follow, and the class-specific keys each one exposes
• Asset References — the grammar object-valued entries accept
• Material Settings — the same reflection idea, applied to UMaterial
• Decompiler — which keys a round trip always emits