数学内置

有 29 个无前缀、按 HLSL 拼写的调用名会被直接降级为算术 UMaterialExpression 节点。它们覆盖 26 种 运算 —— 其中三个名字是别名。除 reflect 和 refract 外，每次调用生成一个节点；这两个 Unreal 没有对应 表达式，会展开成一小张子图。

float s     = sin(X);
float sa    = saturate(X);
vec3  mixed = lerp(A, B, sa);
vec3  unit  = normalize(mixed);
float d     = dot(unit, A);

它们是裸调用 —— 写 saturate(x)，不是 UE.saturate(x) —— 也是唯一一个参数为位置参数的内置调用面。 可以写在 Graph 体内、Outputs 的绑定表达式中，或 Outputs 声明的初始化式中。

所有名字都不区分大小写：SATURATE(x)、Lerp(a, b, t) 和 Sin(x) 都能解析。

语法概要

{ abs | acos | asin | atan | ceil | cos | floor | frac | fract | length
| normalize | saturate | sin | sqrt } ( <x> )
{ atan2 | cross | dot | fmod | max | min | mod | pow | reflect | step } ( <x> , <y> )
{ clamp | lerp | mix | refract | smoothstep } ( <x> , <y> , <z> )

目录

每个可接受写法一行。返回宽度是生成器赋给结果的分量数；权威表示该宽度是否参与 运算符与转换中的加宽规则。

别名

三对别名。每对中的两种写法可以互换，生成的节点完全相同 —— 都没有被弃用。

在 Function 的 HLSL 体内部，标识符 mod 会被 GLSL 别名处理改写成 fmod。在 Graph 块中两种写法都被直接接受，不做改写。

参数规则

下列规则对上面每个内置节点都完全一致。

命名参数

每个参数个数检查的判断都是「参数个数不对或者某个参数带名字」，两种情况都发出同一条个数错误消息。

名称解析

数学内置的名字在任何用户声明的名字之前解析。Graph 的调用分派器按下列顺序判断：

逐个内置节点的说明

clamp

clamp(Input, Min, Max) 会连接全部三个参数，并把节点的 ClampMode 保持在默认值 CMODE_Clamp。 要用 CMODE_ClampMin 或 CMODE_ClampMax，走通用形式：

UE.Expression(Class = "Clamp", OutputType = "float1", Input = x, Min = a, ClampMode = "CMODE_ClampMin")

dot

唯一返回宽度固定的内置节点。无论参数宽度是多少，dot 总是产生 1 分量的权威结果，所以 float d = dot(A, B); 不需要 swizzle。

fmod、mod

参数 1 是被除数，参数 2 是除数，分别连到节点的 A 和 B pin。结果取被除数的宽度。

lerp、mix

结果宽度是参数 1 和 2 的 max —— Alpha 参数不参与。用标量 Alpha 混合两个 vec3 得到 vec3。

min、max

这两个名字共用一套实现，区别只在选择的节点类。两者都取两个参数宽度的 max。

normalize

唯一一个输入 pin 不叫 Input 的内置节点。这条路径上的输入按反射属性名绑定，而 UMaterialExpressionNormalize 把它的 pin 命名为 VectorInput。这个差异在调用点是看不见的 —— normalize(N) —— 但会出现在 could not bind input / failed to access input 这两条诊断里。

sin、cos

两者都把节点的 Period 属性保持在默认值。要用非默认周期：

UE.Expression(Class = "Sine", OutputType = "float1", Input = x, Period = 2.0)

step

step(edge, x) 返回 x >= edge ? 1 : 0，和 HLSL 一致。但 UMaterialExpressionStep 的 pin 命名是反过来的 —— Y 是 edge、X 是 value —— 所以参数 1 连到 Y、参数 2 连到 X。手写节点形式的等价调用是：

UE.Expression(Class = "Step", OutputType = "float1", Y = edge, X = x)

smoothstep

smoothstep(min, max, x)，参数顺序同 HLSL，直接连到节点的 Min、Max 和 Value pin。

length、cross

除 dot 之外仅有的两个返回宽度固定的内置：无论参数是什么，length 恒为 1 分量、cross 恒为 3 分量， 两者的宽度都是权威的。这与同样这两个类经 UE.Expression 触达时报告的 宽度一致。

asin、acos、atan、atan2

四个反三角节点。atan2(y, x) 的参数顺序同 HLSL，而节点的 pin 本来就叫 Y 和 X，所以映射是直接的。

reflect、refract

仅有的两个背后不是一个节点的内置。Unreal 既没有 Reflect 也没有 Refract 表达式，所以两者都被降级成 HLSL 对它们的定义，返回给调用方的是那张子图的最后一个节点。

reflect(i, n) 展开成 i - 2 * dot(i, n) * n —— 四个节点（DotProduct、两个 Multiply、Subtract）。 字面量 2 骑在 Multiply 的 ConstB 上，不额外花一个 Constant 节点。

refract(i, n, eta) 展开成完整的 HLSL 定义 —— 十四个节点：

k = 1 - eta*eta * (1 - dot(n, i)^2)
k < 0 ? 0 : eta*i - (eta*dot(n, i) + sqrt(k)) * n

全内反射的判断是一个 If 节点，所以两侧都会被翻译、再选其一；对负 k 取 sqrt 只落在被丢弃的那一侧， 和 HLSL 完全一样。k == 0 仍然满足公式（sqrt(0) == 0）并走折射侧。零分支写成 i * 0 而不是常量， 是为了让它的类型永远等于 i 的类型 —— If 要求两个分支一致，而追踪到的分量数并不总能保证手挑的常量对得上。

节点复用

结果会做公共子表达式缓存。两个文本相同、操作数值也相同的调用 —— 写了两次的 sin(X) —— 只产生一个 Sine 节点，而不是两个。缓存键覆盖内置名、节点类和每个参数值。

数学内置和通用的 UE.Expression 路径以及 Substrate.* 包装节点共享这一行为。已注册的 UE.* 内置节点是例外：它们每次调用都新建节点。

每个数学节点都创建在编辑器 X 坐标 360 上，Y 取自生成器的布局计数器。

这里没有的东西

矩阵不在其中，而且加不了。 Unreal 材质图根本没有矩阵值类型，所以无论 DSL 怎么做，mul(M, v) 都不会有 Graph 写法。空间转换用 UE.Expression(Class = "Transform") 或 "TransformPosition"，其余的写在 Function 的 HLSL 体里。

仍然缺席、但各自都有节点因而可以经 UE.Expression 触达的：指数、对数、 tan、sign、round、trunc 和 distance。例如：

UE.Expression(Class = "Distance", OutputType = "float1", A = u, B = v)

在 Function 的 HLSL 体内部，这些名字根本不由这个分派器处理 —— 函数体原样输出， 适用的是 HLSL 自己的内建函数。

诊断

{Name} 是作者书写的写法，保留原始大小写。{Index} 从 1 开始。

完整清单见错误速查。

示例

Shader(Name="Docs/M_MathBuiltins")
{
    Properties = {
        float X = 0.5;
        vec3  A = vec3(1.0, 0.0, 0.0);
        vec3  B = vec3(0.0, 1.0, 0.0);
    }
    Settings = { Domain = "UI"; ShadingModel = "Unlit"; }
    Outputs  = { vec3 Color; Base.EmissiveColor = Color; }
    Graph = {
        float s     = sin(X);
        float c     = cos(X);
        float cl    = clamp(X, 0.0, 1.0);
        float sa    = saturate(X);
        vec3  mixed = lerp(A, B, sa);
        vec3  unit  = normalize(mixed);
        float d     = dot(unit, A);
        Color = mixed * (s + c + cl) + unit * d;
    }
}

生成的节点：

Sine(X)                       -> s
Cosine(X)                     -> c
Clamp(X, 0.0, 1.0)            -> cl
Saturate(X)                   -> sa
LinearInterpolate(A, B, sa)   -> mixed     (3 components: max(3, 3))
Normalize(mixed)              -> unit      (3 components)
DotProduct(unit, A)           -> d         (1 component, always)
Add / Multiply chain          -> Color

接下来