Unreal Material Editing

Custom HLSL

For MaterialExpressionCustom, the Code property contains HLSL and InputNames defines custom inputs:

N_new0 MaterialExpressionCustom {Code:"float3 result = Input1 * Input2;\nreturn result;", OutputType:CMOT_Float3, InputNames:["A","B"]}

Defining Functions via Struct Wrapping

UE's Custom node does support function definitions — wrap them inside a struct. Direct top-level function definitions (float Foo(){...}) are rejected by the compiler, but struct member functions work:

struct MyHelpers
{
    float Hash(float t)
    {
        return frac(sin(t * 613.2) * 614.8);
    }

    float2 Hash2D(float t)
    {
        return float2(
            frac(sin(t * 213.3) * 314.8) - 0.5,
            frac(sin(t * 591.1) * 647.2) - 0.5
        );
    }

    float3 Compute(float2 uv, float time)
    {
        float h = Hash(time);
        float2 offset = Hash2D(time);
        return float3(uv + offset, h);
    }
} Helpers;              // <-- instance name after closing brace

return Helpers.Compute(UV, Time);   // call via instance

Key rules:

1. Define a struct with all helper functions as member methods.
2. Declare an instance immediately after the closing brace: } InstanceName;
3. Call functions via the instance: InstanceName.FunctionName(args).
4. Struct methods can call other methods in the same struct freely.
5. Multiple structs are allowed — each must have its own instance name.
6. Prefer struct functions over #define macros — they support proper scoping, recursion-free multi-line logic, and the compiler gives better error messages.

Material Instances

Material instance parameter editing uses SetObjectProperty from the unreal-object-operation skill, not NodeCode. NodeCode is for editing the parent material's node graph.

Workflow

1. Outline — see what sections exist
2. ReadGraph("Properties") — check current material settings
3. ReadGraph("Material") — get the full node graph
4. Modify — edit properties and/or nodes
5. WriteGraph("Properties", text) — update settings
6. WriteGraph("Material", text) — update graph (auto-recompiles)

Key Rules

1. Preserve node IDs — existing nodes have N_<base62> IDs that encode their GUID. Always keep them unchanged when writing back. Use N_new<int> only for genuinely new nodes.
2. [Material] is the complete main graph — no per-output-pin splitting.
3. ReadGraph before WriteGraph — always read first.
4. All operations support Undo (Ctrl+Z).
5. Incremental diff — only changed nodes/connections are modified.
6. Every node needs output connections — nodes without > -> lines that aren't reachable from material outputs will be deleted as orphans. This is especially important for source-only nodes (constants, Time, ScreenPosition, ViewSize, etc.).
7. Connections are output-side only — you declare where a node's output goes by writing > -> lines under it. There is no way to declare an incoming connection on the target side.
8. Track dimensions through the graph — UE material nodes have strict type rules. Binary math nodes broadcast (float1 op floatN → floatN). AppendVector concatenates dimensions with a max of float4. ComponentMask reduces dimensions. DotProduct and Length always output float1. When building complex graphs, mentally track the dimension at each node to avoid overflow at AppendVector. See the Dimension Rules section below.
9. Verify all node IDs before writing — every N_<id> referenced in > -> connection lines must be defined as a node line in the same graph. Referencing an undefined ID will silently drop that connection.
10. Pin name rule — single-input nodes (Sine, Cosine, Abs, Saturate, OneMinus, ComponentMask, Length, etc.) use Input as their pin name or omit it entirely. NEVER use .A or .B for single-input nodes — those names only exist on binary nodes (Multiply, Add, DotProduct, etc.).

Dimension Rules

UE material compiler enforces strict dimension rules. Track the float-width through your node chain:

Common pitfall: passing a float2 through Multiply(float2, float2) still yields float2, but then AppendVector(float2, float2) yields float4. Another AppendVector with that float4 will fail to compile.

Error Handling

• Check diff object in response for changes applied.
• Unknown expression class: "Unknown expression class: ...".
• Pin not found: "Input 'X' not found on N_... (ClassName). Available: [...]".