reze-engine 0.41.0 → 0.41.2

package/dist/graph/registry.js

@@ -31,17 +31,21 @@ export function fmtValue(value, type) {
             return `vec3f(${fmtFloat(x)})`;
         return `vec3f(${fmtFloat(x)}, ${fmtFloat(y)}, ${fmtFloat(z)})`;
     }
+    if (type === "float")
+        throw new Error(`color literal on float socket`);
+    // Blender's colour sockets are RGBA, so a ported literal arrives with four
+    // components whatever it feeds. Only a stop colour keeps the alpha; every other
+    // socket here is a vec3 and drops it, which is what Blender does downstream.
     if (type !== "vec4")
-        throw new Error(`vec4 literal on ${type} socket`);
+        return fmtValue([value[0], value[1], value[2]], type);
     return `vec4f(${value.map(fmtFloat).join(", ")})`;
 }
 /** Does a literal's shape fit a socket type? (Scalar splats onto color/vector/vec4.) */
 export function literalFits(value, type) {
     if (typeof value === "number")
         return true;
-    if (value.length === 3)
-        return type !== "float";
-    return type === "vec4";
+    // 3 and 4 components both fit anything but a float — see fmtValue on RGBA.
+    return type !== "float";
 }
 // ─── Implicit socket conversions (Blender-faithful) ──────────────────
 // vec4 appears only on ramp stop-color literals — never linkable, so conversions
@@ -90,6 +94,18 @@ const RAMP_OUTPUTS = { color: "color", alpha: "float", fac_out: "float" };
 // fac_out (.r) matches how a grayscale ramp feeds a scalar consumer in the hand ports —
 // routing through the BT.601 color→float conversion instead would change the value.
 const RAMP_SELECT = { color: ".rgb", alpha: ".a", fac_out: ".r" };
+/** Principled v2 reflectance, evaluated at compile time when it can be. */
+function foldSpecular(ior, level) {
+    const i = Number(ior);
+    const l = Number(level);
+    if (!Number.isFinite(i) || !Number.isFinite(l))
+        return `principled_specular(${ior}, ${level})`;
+    const r = (i - 1) / Math.max(i + 1, 1e-6);
+    // Snapped to 9 significant digits: the arithmetic leaves double noise
+    // (0.2² · 2 · 0.5 / 0.08 = 0.5000000000000001) that is meaningless in an f32
+    // and only makes the emitted shader harder to read.
+    return fmtFloat(Number(((r * r * 2 * Math.max(l, 0)) / 0.08).toPrecision(9)));
+}
 export const NODE_REGISTRY = {
     // ── Context inputs (template locals; no emission) ──
     texture: {
@@ -118,6 +134,42 @@ export const NODE_REGISTRY = {
             reflection: "reflect(-v, n)",
         },
     },
+    // The scene's key light. Blender NPR presets rarely use a diffuse closure —
+    // they build their own term, typically dot(normal, direction) pushed through a
+    // ramp or a soft threshold band, because that is what gives an anime shader its
+    // hard terminator. Reaching that term needs the direction as a value, which no
+    // other node exposes: `shader_to_rgb*` and `bsdf_diffuse` bake the whole closure
+    // and hand back a result. `shadow` is the same cascade sample those closures
+    // take, so a graph can tint its own shadow instead of accepting theirs.
+    //
+    // A ported graph reads `direction` where the Blender original read an Attribute
+    // fed by a light empty; the empty and our sun mean the same thing.
+    light: {
+        inputs: {},
+        outputs: { direction: "vector", color: "color", ambient: "color", shadow: "float" },
+        contextOutputs: { direction: "l", color: "sun", ambient: "amb", shadow: "shadow" },
+    },
+    // The head bone's world basis — what an SDF face shadow is built on.
+    //
+    // That technique compares a face-shaped distance field against the light's
+    // angle IN THE HEAD'S OWN FRAME, so the shadow sweeps across the face as the
+    // light moves and stays put as the head turns. Without the frame there is
+    // nothing to measure the angle against, and the effect cannot be expressed at
+    // all. `right` also carries the sign that mirrors the field's U coordinate,
+    // which is how one half-face texture serves both sides.
+    //
+    // Read from the 頭 bone's skinning matrix, already bound to the fragment stage
+    // for the eye's rear-view gate. A model without that bone falls back to bone 0
+    // rather than sampling out of bounds; the face shadow is then wrong, not unsafe.
+    head_basis: {
+        inputs: {},
+        outputs: { forward: "vector", right: "vector", up: "vector" },
+        contextOutputs: {
+            forward: "(-normalize(skinMats[u32(max(material.headBoneIndex, 0.0))][2].xyz))",
+            right: "normalize(skinMats[u32(max(material.headBoneIndex, 0.0))][0].xyz)",
+            up: "normalize(skinMats[u32(max(material.headBoneIndex, 0.0))][1].xyz)",
+        },
+    },
     // PMX material's diffuse color (the authored base tint). Multiply the diffuse texture
     // by this for the MMD-correct base — untextured materials carry their color here, so a
     // texture-only base would render them white.
@@ -136,6 +188,258 @@ export const NODE_REGISTRY = {
         outputs: { color: "color" },
         emit: (a) => `pmx_sphere_map(${a.base}, ${a.strength}, n)`,
     },
+    // ── Blender 5.2 Math node, full operation set ──
+    "math/absolute": { inputs: { a: F(0) }, outputs: { value: "float" }, emit: (a) => `math_absolute(${a.a})` },
+    "math/sqrt": { inputs: { a: F(0) }, outputs: { value: "float" }, emit: (a) => `math_sqrt(${a.a})` },
+    "math/inversesqrt": { inputs: { a: F(0) }, outputs: { value: "float" }, emit: (a) => `math_inversesqrt(${a.a})` },
+    "math/exponent": { inputs: { a: F(0) }, outputs: { value: "float" }, emit: (a) => `math_exponent(${a.a})` },
+    "math/sign": { inputs: { a: F(0) }, outputs: { value: "float" }, emit: (a) => `math_sign(${a.a})` },
+    "math/round": { inputs: { a: F(0) }, outputs: { value: "float" }, emit: (a) => `math_round(${a.a})` },
+    "math/floor": { inputs: { a: F(0) }, outputs: { value: "float" }, emit: (a) => `math_floor(${a.a})` },
+    "math/ceil": { inputs: { a: F(0) }, outputs: { value: "float" }, emit: (a) => `math_ceil(${a.a})` },
+    "math/truncate": { inputs: { a: F(0) }, outputs: { value: "float" }, emit: (a) => `math_truncate(${a.a})` },
+    "math/fraction": { inputs: { a: F(0) }, outputs: { value: "float" }, emit: (a) => `math_fraction(${a.a})` },
+    "math/sine": { inputs: { a: F(0) }, outputs: { value: "float" }, emit: (a) => `math_sine(${a.a})` },
+    "math/cosine": { inputs: { a: F(0) }, outputs: { value: "float" }, emit: (a) => `math_cosine(${a.a})` },
+    "math/tangent": { inputs: { a: F(0) }, outputs: { value: "float" }, emit: (a) => `math_tangent(${a.a})` },
+    "math/arcsine": { inputs: { a: F(0) }, outputs: { value: "float" }, emit: (a) => `math_arcsine(${a.a})` },
+    "math/arccosine": { inputs: { a: F(0) }, outputs: { value: "float" }, emit: (a) => `math_arccosine(${a.a})` },
+    "math/arctangent": { inputs: { a: F(0) }, outputs: { value: "float" }, emit: (a) => `math_arctangent(${a.a})` },
+    "math/radians": { inputs: { a: F(0) }, outputs: { value: "float" }, emit: (a) => `math_radians(${a.a})` },
+    "math/degrees": { inputs: { a: F(0) }, outputs: { value: "float" }, emit: (a) => `math_degrees(${a.a})` },
+    "math/subtract": { inputs: { a: F(0), b: F(0) }, outputs: { value: "float" }, emit: (a) => `math_subtract(${a.a}, ${a.b})` },
+    "math/divide": { inputs: { a: F(0), b: F(1) }, outputs: { value: "float" }, emit: (a) => `math_divide(${a.a}, ${a.b})` },
+    "math/logarithm": { inputs: { a: F(0), b: F(1) }, outputs: { value: "float" }, emit: (a) => `math_logarithm(${a.a}, ${a.b})` },
+    "math/minimum": { inputs: { a: F(0), b: F(0) }, outputs: { value: "float" }, emit: (a) => `math_minimum(${a.a}, ${a.b})` },
+    "math/maximum": { inputs: { a: F(0), b: F(0) }, outputs: { value: "float" }, emit: (a) => `math_maximum(${a.a}, ${a.b})` },
+    "math/less_than": { inputs: { a: F(0), b: F(0) }, outputs: { value: "float" }, emit: (a) => `math_less_than(${a.a}, ${a.b})` },
+    "math/modulo": { inputs: { a: F(0), b: F(1) }, outputs: { value: "float" }, emit: (a) => `math_modulo(${a.a}, ${a.b})` },
+    "math/floored_modulo": { inputs: { a: F(0), b: F(1) }, outputs: { value: "float" }, emit: (a) => `math_floored_modulo(${a.a}, ${a.b})` },
+    "math/snap": { inputs: { a: F(0), b: F(1) }, outputs: { value: "float" }, emit: (a) => `math_snap(${a.a}, ${a.b})` },
+    "math/pingpong": { inputs: { a: F(0), b: F(1) }, outputs: { value: "float" }, emit: (a) => `math_pingpong(${a.a}, ${a.b})` },
+    "math/arctan2": { inputs: { a: F(0), b: F(0) }, outputs: { value: "float" }, emit: (a) => `math_arctan2(${a.a}, ${a.b})` },
+    "math/multiply_add": { inputs: { a: F(0), b: F(0), c: F(0) }, outputs: { value: "float" }, emit: (a) => `math_multiply_add(${a.a}, ${a.b}, ${a.c})` },
+    "math/compare": { inputs: { a: F(0), b: F(0), c: F(0) }, outputs: { value: "float" }, emit: (a) => `math_compare(${a.a}, ${a.b}, ${a.c})` },
+    "math/smooth_min": { inputs: { a: F(0), b: F(0), c: F(0) }, outputs: { value: "float" }, emit: (a) => `math_smooth_min(${a.a}, ${a.b}, ${a.c})` },
+    "math/smooth_max": { inputs: { a: F(0), b: F(0), c: F(0) }, outputs: { value: "float" }, emit: (a) => `math_smooth_max(${a.a}, ${a.b}, ${a.c})` },
+    "math/wrap": { inputs: { a: F(0), b: F(0), c: F(0) }, outputs: { value: "float" }, emit: (a) => `math_wrap(${a.a}, ${a.b}, ${a.c})` },
+    // ── Blender 5.2 Vector Math node ──
+    "vector_math/normalize": { inputs: { a: V([0, 0, 0], true) }, outputs: { vector: "vector" }, emit: (a) => `vector_normalize(${a.a})` },
+    "vector_math/absolute": { inputs: { a: V([0, 0, 0], true) }, outputs: { vector: "vector" }, emit: (a) => `vector_absolute(${a.a})` },
+    "vector_math/floor": { inputs: { a: V([0, 0, 0], true) }, outputs: { vector: "vector" }, emit: (a) => `vector_floor(${a.a})` },
+    "vector_math/ceil": { inputs: { a: V([0, 0, 0], true) }, outputs: { vector: "vector" }, emit: (a) => `vector_ceil(${a.a})` },
+    "vector_math/fraction": { inputs: { a: V([0, 0, 0], true) }, outputs: { vector: "vector" }, emit: (a) => `vector_fraction(${a.a})` },
+    "vector_math/add": { inputs: { a: V([0, 0, 0], true), b: V() }, outputs: { vector: "vector" }, emit: (a) => `vector_add(${a.a}, ${a.b})` },
+    "vector_math/subtract": { inputs: { a: V([0, 0, 0], true), b: V() }, outputs: { vector: "vector" }, emit: (a) => `vector_subtract(${a.a}, ${a.b})` },
+    "vector_math/multiply": { inputs: { a: V([0, 0, 0], true), b: V() }, outputs: { vector: "vector" }, emit: (a) => `vector_multiply(${a.a}, ${a.b})` },
+    "vector_math/divide": { inputs: { a: V([0, 0, 0], true), b: V() }, outputs: { vector: "vector" }, emit: (a) => `vector_divide(${a.a}, ${a.b})` },
+    "vector_math/cross": { inputs: { a: V([0, 0, 0], true), b: V() }, outputs: { vector: "vector" }, emit: (a) => `vector_cross(${a.a}, ${a.b})` },
+    "vector_math/project": { inputs: { a: V([0, 0, 0], true), b: V() }, outputs: { vector: "vector" }, emit: (a) => `vector_project(${a.a}, ${a.b})` },
+    "vector_math/reflect": { inputs: { a: V([0, 0, 0], true), b: V() }, outputs: { vector: "vector" }, emit: (a) => `vector_reflect(${a.a}, ${a.b})` },
+    "vector_math/minimum": { inputs: { a: V([0, 0, 0], true), b: V() }, outputs: { vector: "vector" }, emit: (a) => `vector_minimum(${a.a}, ${a.b})` },
+    "vector_math/maximum": { inputs: { a: V([0, 0, 0], true), b: V() }, outputs: { vector: "vector" }, emit: (a) => `vector_maximum(${a.a}, ${a.b})` },
+    "vector_math/modulo": { inputs: { a: V([0, 0, 0], true), b: V() }, outputs: { vector: "vector" }, emit: (a) => `vector_modulo(${a.a}, ${a.b})` },
+    "vector_math/snap": { inputs: { a: V([0, 0, 0], true), b: V() }, outputs: { vector: "vector" }, emit: (a) => `vector_snap(${a.a}, ${a.b})` },
+    "vector_math/dot": { inputs: { a: V([0, 0, 0], true), b: V() }, outputs: { value: "float" }, emit: (a) => `vector_dot(${a.a}, ${a.b})` },
+    "vector_math/distance": { inputs: { a: V([0, 0, 0], true), b: V() }, outputs: { value: "float" }, emit: (a) => `vector_distance(${a.a}, ${a.b})` },
+    "vector_math/length": { inputs: { a: V([0, 0, 0], true) }, outputs: { value: "float" }, emit: (a) => `vector_length(${a.a})` },
+    "vector_math/scale": { inputs: { a: V([0, 0, 0], true), scale: F(1) }, outputs: { vector: "vector" }, emit: (a) => `vector_scale(${a.a}, ${a.scale})` },
+    "vector_math/multiply_add": { inputs: { a: V([0, 0, 0], true), b: V(), c: V() }, outputs: { vector: "vector" }, emit: (a) => `vector_multiply_add(${a.a}, ${a.b}, ${a.c})` },
+    "vector_math/faceforward": { inputs: { a: V([0, 0, 0], true), b: V(), c: V() }, outputs: { vector: "vector" }, emit: (a) => `vector_faceforward(${a.a}, ${a.b}, ${a.c})` },
+    "vector_math/refract": { inputs: { a: V([0, 0, 0], true), b: V(), ior: F(1.45) }, outputs: { vector: "vector" }, emit: (a) => `vector_refract(${a.a}, ${a.b}, ${a.ior})` },
+    "vector_math/wrap": { inputs: { a: V([0, 0, 0], true), b: V(), c: V() }, outputs: { vector: "vector" }, emit: (a) => `vector_wrap(${a.a}, ${a.b}, ${a.c})` },
+    // ── Blender 5.2 Mix (Color) blend set ──
+    "mix/add": { inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() }, outputs: { color: "color" }, emit: (a) => `mix_add(${a.fac}, ${a.a}, ${a.b})` },
+    "mix/subtract": { inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() }, outputs: { color: "color" }, emit: (a) => `mix_subtract(${a.fac}, ${a.a}, ${a.b})` },
+    "mix/darken": { inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() }, outputs: { color: "color" }, emit: (a) => `mix_darken(${a.fac}, ${a.a}, ${a.b})` },
+    "mix/difference": { inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() }, outputs: { color: "color" }, emit: (a) => `mix_difference(${a.fac}, ${a.a}, ${a.b})` },
+    "mix/exclusion": { inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() }, outputs: { color: "color" }, emit: (a) => `mix_exclusion(${a.fac}, ${a.a}, ${a.b})` },
+    "mix/screen": { inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() }, outputs: { color: "color" }, emit: (a) => `mix_screen(${a.fac}, ${a.a}, ${a.b})` },
+    "mix/soft_light": { inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() }, outputs: { color: "color" }, emit: (a) => `mix_soft_light(${a.fac}, ${a.a}, ${a.b})` },
+    "mix/dodge": { inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() }, outputs: { color: "color" }, emit: (a) => `mix_dodge(${a.fac}, ${a.a}, ${a.b})` },
+    "mix/burn": { inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() }, outputs: { color: "color" }, emit: (a) => `mix_burn(${a.fac}, ${a.a}, ${a.b})` },
+    "mix/divide": { inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() }, outputs: { color: "color" }, emit: (a) => `mix_divide(${a.fac}, ${a.a}, ${a.b})` },
+    "mix/hue": { inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() }, outputs: { color: "color" }, emit: (a) => `mix_hue(${a.fac}, ${a.a}, ${a.b})` },
+    "mix/saturation": { inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() }, outputs: { color: "color" }, emit: (a) => `mix_saturation(${a.fac}, ${a.a}, ${a.b})` },
+    "mix/value": { inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() }, outputs: { color: "color" }, emit: (a) => `mix_value(${a.fac}, ${a.a}, ${a.b})` },
+    "mix/color": { inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() }, outputs: { color: "color" }, emit: (a) => `mix_color_blend(${a.fac}, ${a.a}, ${a.b})` },
+    // ── RGB Curves, sampled. See rgb_curve in nodes.ts for why five. ──
+    rgb_curve: {
+        inputs: {
+            color: C([1, 1, 1], true),
+            fac: F(1),
+            y0: F(0),
+            y1: F(0.25),
+            y2: F(0.5),
+            y3: F(0.75),
+            y4: F(1),
+        },
+        outputs: { color: "color" },
+        emit: (a) => `mix(${a.color}, rgb_curve(${a.color}, ${a.y0}, ${a.y1}, ${a.y2}, ${a.y3}, ${a.y4}), ${a.fac})`,
+    },
+    // UV Map — one layer on a PMX, which is the mesh UV the texture node uses.
+    uv_map: {
+        inputs: {},
+        outputs: { uv: "vector" },
+        contextOutputs: { uv: "vec3f(input.uv, 0.0)" },
+    },
+    // ── Normal Map, Vector Transform ──
+    normal_map: {
+        inputs: { color: C([0.5, 0.5, 1], true), strength: F(1) },
+        outputs: { normal: "vector" },
+        emit: (a) => `node_normal_map(${a.color}, ${a.strength}, n, input.worldPos, input.uv)`,
+    },
+    "vector_transform/world_to_camera": {
+        inputs: { vector: V([0, 0, 0], true) },
+        outputs: { vector: "vector" },
+        emit: (a) => `vector_world_to_camera(${a.vector})`,
+    },
+    "vector_transform/camera_to_world": {
+        inputs: { vector: V([0, 0, 0], true) },
+        outputs: { vector: "vector" },
+        emit: (a) => `vector_camera_to_world(${a.vector})`,
+    },
+    "vector_transform/point_world_to_camera": {
+        inputs: { vector: V([0, 0, 0], true) },
+        outputs: { vector: "vector" },
+        emit: (a) => `point_world_to_camera(${a.vector})`,
+    },
+    // ── Shader nodes. Shaders travel as RGB here (see shader_to_rgb_diffuse), so
+    // a "transparent" shader is the colour that contributes nothing; the actual
+    // cutout is the group's alphaMode, which is where transparency belongs in a
+    // rasteriser without order-independent blending.
+    bsdf_transparent: { inputs: {}, outputs: { color: "color" }, emit: () => `vec3f(0.0)` },
+    bsdf_diffuse: {
+        inputs: { color: C([0.8, 0.8, 0.8], true) },
+        outputs: { color: "color" },
+        emit: (a) => `${a.color} * shader_to_rgb_lit(n, l, sun, amb, shadow)`,
+    },
+    // ── Nodes with no meaning on a PMX, answered honestly with a constant ──
+    // Each returns what Blender returns for the absent case, so a graph that reads
+    // one degrades to a sensible look instead of failing to compile. Documented
+    // rather than silently wrong.
+    //
+    // attribute: MMD meshes carry no vertex colour layer, so Color reads white and
+    // Fac reads 1 — the identity for the multiply these usually feed.
+    attribute: {
+        inputs: {},
+        outputs: { color: "color", fac: "float" },
+        contextOutputs: { color: "vec3f(1.0)", fac: "1.0" },
+    },
+    // object_info: one model, one instance — Random is the only field with a real
+    // use (per-instance variation) and there are no instances to vary.
+    object_info: {
+        inputs: {},
+        outputs: { location: "vector", color: "color", random: "float" },
+        contextOutputs: { location: "vec3f(0.0)", color: "vec3f(1.0)", random: "0.0" },
+    },
+    // light_path: this is a raster pass, so every shaded fragment IS a camera ray.
+    light_path: {
+        inputs: {},
+        outputs: { is_camera_ray: "float", is_shadow_ray: "float", ray_depth: "float" },
+        contextOutputs: { is_camera_ray: "1.0", is_shadow_ray: "0.0", ray_depth: "0.0" },
+    },
+    // ── Image Texture on a style-group slot ──
+    // The PMX gives a material ONE image; this style needs several, so the extra
+    // maps ride on the group. Slot is part of the type because it selects a
+    // binding, which is topology rather than a value. The uv input defaults to the
+    // mesh UV, matching an unlinked Vector socket in Blender.
+    "tex_image/0": {
+        inputs: { uv: { type: "vector", contextDefault: "vec3f(input.uv, 0.0)" } },
+        outputs: { color: "color", alpha: "float" },
+        outputSelect: { color: ".rgb", alpha: ".a" },
+        emit: (a) => `group_tex0(${a.uv}.xy)`,
+    },
+    "tex_image/1": {
+        inputs: { uv: { type: "vector", contextDefault: "vec3f(input.uv, 0.0)" } },
+        outputs: { color: "color", alpha: "float" },
+        outputSelect: { color: ".rgb", alpha: ".a" },
+        emit: (a) => `group_tex1(${a.uv}.xy)`,
+    },
+    "tex_image/2": {
+        inputs: { uv: { type: "vector", contextDefault: "vec3f(input.uv, 0.0)" } },
+        outputs: { color: "color", alpha: "float" },
+        outputSelect: { color: ".rgb", alpha: ".a" },
+        emit: (a) => `group_tex2(${a.uv}.xy)`,
+    },
+    "tex_image/3": {
+        inputs: { uv: { type: "vector", contextDefault: "vec3f(input.uv, 0.0)" } },
+        outputs: { color: "color", alpha: "float" },
+        outputSelect: { color: ".rgb", alpha: ".a" },
+        emit: (a) => `group_tex3(${a.uv}.xy)`,
+    },
+    // ── Blender 5.2 colour utilities ──
+    separate_color: {
+        inputs: { color: C([1, 1, 1], true) },
+        outputs: { r: "float", g: "float", b: "float" },
+        outputSelect: { r: ".r", g: ".g", b: ".b" },
+        emit: (a) => a.color,
+    },
+    "separate_color/hsv": {
+        inputs: { color: C([1, 1, 1], true) },
+        outputs: { h: "float", s: "float", v: "float" },
+        outputSelect: { h: ".x", s: ".y", v: ".z" },
+        emit: (a) => `rgb_to_hsv(${a.color})`,
+    },
+    "separate_color/hsl": {
+        inputs: { color: C([1, 1, 1], true) },
+        outputs: { h: "float", s: "float", l: "float" },
+        outputSelect: { h: ".x", s: ".y", l: ".z" },
+        emit: (a) => `rgb_to_hsl(${a.color})`,
+    },
+    combine_color: {
+        inputs: { r: F(0), g: F(0), b: F(0) },
+        outputs: { color: "color" },
+        emit: (a) => `vec3f(${a.r}, ${a.g}, ${a.b})`,
+    },
+    "combine_color/hsv": {
+        inputs: { h: F(0), s: F(0), v: F(0) },
+        outputs: { color: "color" },
+        emit: (a) => `hsv_to_rgb(vec3f(${a.h}, ${a.s}, ${a.v}))`,
+    },
+    "combine_color/hsl": {
+        inputs: { h: F(0), s: F(0), l: F(0) },
+        outputs: { color: "color" },
+        emit: (a) => `hsl_to_rgb(vec3f(${a.h}, ${a.s}, ${a.l}))`,
+    },
+    combine_xyz: {
+        inputs: { x: F(0), y: F(0), z: F(0) },
+        outputs: { vector: "vector" },
+        emit: (a) => `vec3f(${a.x}, ${a.y}, ${a.z})`,
+    },
+    gamma: {
+        inputs: { color: C([1, 1, 1], true), gamma: F(1) },
+        outputs: { color: "color" },
+        emit: (a) => `node_gamma(${a.color}, ${a.gamma})`,
+    },
+    // Map Range: the interpolation is topology, as everywhere else here. The
+    // clamped form is Blender's default, which is why it carries the bare name.
+    map_range: {
+        inputs: { value: F(0, true), from_min: F(0), from_max: F(1), to_min: F(0), to_max: F(1) },
+        outputs: { value: "float" },
+        emit: (a) => `map_range_clamped(${a.value}, ${a.from_min}, ${a.from_max}, ${a.to_min}, ${a.to_max})`,
+    },
+    "map_range/linear": {
+        inputs: { value: F(0, true), from_min: F(0), from_max: F(1), to_min: F(0), to_max: F(1) },
+        outputs: { value: "float" },
+        emit: (a) => `map_range_linear(${a.value}, ${a.from_min}, ${a.from_max}, ${a.to_min}, ${a.to_max})`,
+    },
+    "map_range/smoothstep": {
+        inputs: { value: F(0, true), from_min: F(0), from_max: F(1), to_min: F(0), to_max: F(1) },
+        outputs: { value: "float" },
+        emit: (a) => `map_range_smooth(${a.value}, ${a.from_min}, ${a.from_max}, ${a.to_min}, ${a.to_max})`,
+    },
+    // Vector Rotate — the rotation TYPE is topology.
+    "vector_rotate/axis_angle": {
+        inputs: { vector: V([0, 0, 0], true), center: V(), axis: V([0, 0, 1]), angle: F(0) },
+        outputs: { vector: "vector" },
+        emit: (a) => `vector_rotate_axis(${a.vector}, ${a.center}, ${a.axis}, ${a.angle})`,
+    },
+    "vector_rotate/euler_xyz": {
+        inputs: { vector: V([0, 0, 0], true), center: V(), rotation: V() },
+        outputs: { vector: "vector" },
+        emit: (a) => `vector_rotate_euler(${a.vector}, ${a.center}, ${a.rotation})`,
+    },
     // ── Literals as nodes (for editor ergonomics; inlined literals work too) ──
     value: { inputs: { value: F(0) }, outputs: { value: "float" }, emit: (a) => a.value },
     rgb: { inputs: { color: C() }, outputs: { color: "color" }, emit: (a) => a.color },
@@ -179,8 +483,27 @@ export const NODE_REGISTRY = {
         outputSelect: RAMP_SELECT,
         emit: (a) => `ramp_constant_edge_aa(${a.fac}, ${a.edge}, ${a.color0}, ${a.color1})`,
     },
+    // Blender ColorRamp LINEAR with three arbitrary stops. A two-stop ramp cannot
+    // express a shadow that passes through a colour on its way — a warm terminator
+    // between cool shadow and lit skin is three stops, and that middle band is
+    // where a lot of NPR character lives. Decomposing it into two ramps and a
+    // select costs three extra nodes and stops reading as a ramp.
+    ramp_linear_3: {
+        inputs: {
+            fac: F(0.5, true),
+            pos0: F(0),
+            color0: V4([0, 0, 0, 1]),
+            pos1: F(0.5),
+            color1: V4([0.5, 0.5, 0.5, 1]),
+            pos2: F(1),
+            color2: V4([1, 1, 1, 1]),
+        },
+        outputs: RAMP_OUTPUTS,
+        outputSelect: RAMP_SELECT,
+        emit: (a) => `ramp_linear3(${a.fac}, ${a.pos0}, ${a.color0}, ${a.pos1}, ${a.color1}, ${a.pos2}, ${a.color2})`,
+    },
     // Blender ColorRamp LINEAR with 3 stops black→white→black (triangular peak at 0.5).
-    // The only >2-stop ramp the presets use; folded to closed form like the hand port.
+    // Folded to closed form like the hand port.
     ramp_tri: {
         inputs: { fac: F(0.5, true) },
         outputs: { value: "float" },
@@ -270,11 +593,35 @@ export const NODE_REGISTRY = {
         emit: (a) => `layer_weight_facing(${a.blend}, n, v)`,
     },
     // ── Lighting capture ──
+    /**
+     * Shader → RGB on a white diffuse closure, reduced to a scalar.
+     *
+     * Rec.709 luminance, kept exactly as it was: every shipped preset ramps this,
+     * and changing the weights would move every terminator in the library.
+     */
     shader_to_rgb_diffuse: {
         inputs: {},
         outputs: { value: "float" },
         emit: () => `shader_to_rgb_diffuse(n, l, sun, amb, shadow)`,
     },
+    /**
+     * The same closure as a COLOUR, which is what Blender's Shader to RGB
+     * actually returns.
+     *
+     * A warm sun against a cool ambient radiates warm light and cool shadow, and
+     * that colour IS the look in most of this style. Reducing it to luminance
+     * first — the only thing reachable before — leaves every ramp working on grey.
+     *
+     * Linking this into a scalar socket still yields a float, because Blender's
+     * own implicit Color → Value conversion (BT.601) happens at the link. So the
+     * two nodes differ only in whether the graph wants the colour or the scalar,
+     * and each gets Blender's answer for its own question.
+     */
+    shader_to_rgb: {
+        inputs: {},
+        outputs: { color: "color" },
+        emit: () => `shader_to_rgb_lit(n, l, sun, amb, shadow)`,
+    },
     // ── Vector ──
     separate_xyz: {
         inputs: { vector: V([0, 0, 0], true) },
@@ -323,18 +670,87 @@ export const NODE_REGISTRY = {
     // ── Principled BSDF (frozen 3.6 legacy-EEVEE semantics: eval_principled port) ──
     // normal defaults to the template's shading normal; link a bump/normal_map chain
     // to perturb it (body/cloth_rough noise bump).
+    /**
+     * Principled BSDF, Blender 5.2 socket names.
+     *
+     * v2 (4.0+) renamed most of what a graph touches and re-derived one of them,
+     * which is exactly where a transcribed port goes quietly wrong: Specular
+     * became "Specular IOR Level" and no longer sets reflectance directly — IOR
+     * does, and the level scales it. So f0 is computed the v2 way here, and the
+     * defaults land on 0.04 for ior 1.5 at level 0.5, matching both versions at
+     * their defaults while tracking v2 when a preset moves either.
+     *
+     * Emission Strength defaults to 0 in v2 where 3.6's Emission was visible, so a
+     * naive port turns every emissive material black. Following v2 means honouring
+     * that default and letting the preset say otherwise.
+     *
+     * Not implemented, and not silently wrong — a graph setting these gets the
+     * base BSDF rather than a wrong approximation of them: Coat, Transmission,
+     * Subsurface, Anisotropic, Thin Film. They need path-traced or
+     * multi-scatter machinery this renderer does not have.
+     */
     principled: {
         inputs: {
-            base: C([0.8, 0.8, 0.8], true),
+            base_color: C([0.8, 0.8, 0.8], true),
             metallic: F(0),
-            specular: F(0.5),
             roughness: F(0.5),
-            spec_clamp: F(1e30),
-            sheen: F(0),
+            ior: F(1.5),
+            specular_ior_level: F(0.5),
+            sheen_weight: F(0),
             sheen_tint: F(0),
+            emission_color: C([1, 1, 1]),
+            emission_strength: F(0),
             normal: { type: "vector", contextDefault: "n" },
+            /** Ours, not Blender's: caps firefly speculars from noise-bumped NDF
+             *  aliasing, which EEVEE hides behind TAA and we have none. */
+            spec_clamp: F(1e30),
         },
         outputs: { color: "color" },
-        emit: (a) => `eval_principled(PrincipledIn(${a.base}, ${a.metallic}, ${a.specular}, ${a.roughness}, ${a.spec_clamp}, ${a.sheen}, ${a.sheen_tint}), ${a.normal}, l, v, sun, amb, shadow)`,
+        emit: (a) => {
+            // Fold the reflectance when both sockets are literals, which is nearly
+            // always. It keeps the emitted WGSL as tight as the 3.6 form was — and at
+            // the defaults it folds to exactly 0.5, which is what 3.6's Specular held,
+            // so the two versions agree byte-for-byte where a preset changed nothing.
+            const spec = foldSpecular(a.ior, a.specular_ior_level);
+            const bsdf = `eval_principled(PrincipledIn(${a.base_color}, ${a.metallic}, ` +
+                `${spec}, ${a.roughness}, ` +
+                `${a.spec_clamp}, ${a.sheen_weight}, ${a.sheen_tint}), ${a.normal}, l, v, sun, amb, shadow)`;
+            // v2 defaults Emission Strength to 0, which is the overwhelming case. Emit
+            // the term only when it can do something, so the common shader carries no
+            // dead add and the output stays readable.
+            return a.emission_strength === "0.0" ? bsdf : `${bsdf} + ${a.emission_color} * ${a.emission_strength}`;
+        },
     },
 };
+// ─── Blender socket parity ────────────────────────────────────────────
+// Blender's Math node carries three Value inputs whatever operation is selected,
+// its Vector Math node three Vectors plus a Scale, and Vector Rotate the union of
+// every rotation type's inputs. Sockets are part of the node, not of the mode.
+//
+// Declaring the same set here is what makes a port mechanical: a transcriber maps
+// socket-for-socket and never has to know which inputs a given operation happens
+// to read. The emit functions read only what their operation uses, so the added
+// sockets change no generated WGSL — an unread one is inert.
+//
+// Applied as a pass rather than written into each entry so that every operation
+// KEEPS the default it already declared (divide's b is 1, not 0). Only genuinely
+// missing sockets are added.
+function widen(prefix, sockets) {
+    for (const [key, spec] of Object.entries(NODE_REGISTRY)) {
+        if (!key.startsWith(prefix))
+            continue;
+        for (const [name, def] of Object.entries(sockets)) {
+            if (!(name in spec.inputs))
+                spec.inputs[name] = def;
+        }
+    }
+}
+widen("math/", { a: F(0), b: F(0), c: F(0) });
+widen("vector_math/", { a: V(), b: V(), c: V(), scale: F(1) });
+widen("vector_rotate/", {
+    vector: V([0, 0, 0], true),
+    center: V(),
+    axis: V([0, 0, 1]),
+    angle: F(0),
+    rotation: V(),
+});

package/dist/graph/style-group.d.ts

@@ -15,6 +15,52 @@ export type StyleGroup = {
     renderClass?: RenderClass;
     /** Alpha-handling axis, orthogonal to renderClass. Default "opaque". */
     alphaMode?: AlphaMode;
+    /**
+     * Extra image maps for this group's shading, up to four.
+     *
+     * A PMX material carries exactly ONE image, and a Blender-authored look is
+     * usually built on more than that — a lightmap encoding shadow thresholds and
+     * specular masks in its channels, a ramp, a detail map. Those belong to the
+     * LOOK rather than to the model, so they ride on the group: the same graph
+     * applied to another character brings its own maps with it.
+     *
+     * Read by the `tex_image/0`…`tex_image/3` nodes, in order. A slot left empty
+     * (or a graph reading past the end) samples 1×1 white, so a missing map is a
+     * no-op rather than a failure.
+     */
+    images?: (GroupImage | GroupImageSource | null)[];
+};
+export type GroupImageSource = ImageBitmap | HTMLImageElement | HTMLCanvasElement;
+/**
+ * A group map, with the one thing the engine cannot infer from the pixels:
+ * whether they are colour.
+ *
+ * A PMX texture is always colour, so material textures are uploaded sRGB
+ * unconditionally. A group's maps are not — half of them are data whose channels
+ * encode thresholds, masks and distances, and running those through an sRGB
+ * decode bends every value. Blender asks the same question per image, and a
+ * ported look carries whatever answer it was authored with.
+ *
+ * A bare source reads as data (`srgb: false`), because a map that is silently
+ * mis-decoded as colour is the harder failure to see: it renders, just wrong.
+ */
+/**
+ * `premultiplied` — whether the upload should multiply RGB by alpha.
+ *
+ * Blender premultiplies a straight-alpha image for rendering, so a transparent
+ * pixel contributes nothing. A highlight texture is white everywhere with its
+ * shape only in alpha, and without this it screens to a white card instead of
+ * resolving to its shape. Left off for a channel-packed map, whose alpha is a
+ * separate signal and would scale colour by something unrelated.
+ *
+ * It has to happen HERE rather than in the host's decode: copyExternalImageToTexture
+ * converts to the destination's tagged alpha mode, so a premultiplied ImageBitmap
+ * copied into an untagged texture is un-premultiplied again on the way in.
+ */
+export type GroupImage = {
+    source: GroupImageSource;
+    srgb?: boolean;
+    premultiplied?: boolean;
 };
 export type GroupDiagnostic = {
     groupId: string;

package/dist/graph/style-group.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"style-group.d.ts","sourceRoot":"","sources":["../../src/graph/style-group.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAE1C,MAAM,MAAM,UAAU,GAAG;IACvB,wFAAwF;IACxF,EAAE,EAAE,MAAM,CAAA;IACV;2CACuC;IACvC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,2EAA2E;IAC3E,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,sFAAsF;IACtF,KAAK,EAAE,WAAW,CAAA;IAClB,uEAAuE;IACvE,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,wEAAwE;IACxE,SAAS,CAAC,EAAE,SAAS,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,UAAU,EAAE,CAAC;IAAC,EAAE,EAAE,OAAO,CAAA;CAAE,CAAA;AAEzF,MAAM,MAAM,sBAAsB,GAAG;IACnC,sCAAsC;IACtC,EAAE,EAAE,OAAO,CAAA;IACX,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB,iEAAiE;IACjE,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,kFAAkF;IAClF,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,UAAU,EAAE,CAAC;IAAC,OAAO,EAAE,SAAS,EAAE,CAAA;CAAE,CAAA"}
+{"version":3,"file":"style-group.d.ts","sourceRoot":"","sources":["../../src/graph/style-group.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAE1C,MAAM,MAAM,UAAU,GAAG;IACvB,wFAAwF;IACxF,EAAE,EAAE,MAAM,CAAA;IACV;2CACuC;IACvC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,2EAA2E;IAC3E,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,sFAAsF;IACtF,KAAK,EAAE,WAAW,CAAA;IAClB,uEAAuE;IACvE,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,wEAAwE;IACxE,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,EAAE,CAAC,UAAU,GAAG,gBAAgB,GAAG,IAAI,CAAC,EAAE,CAAA;CAClD,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,WAAW,GAAG,gBAAgB,GAAG,iBAAiB,CAAA;AAEjF;;;;;;;;;;;;GAYG;AACH;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,MAAM,EAAE,gBAAgB,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,CAAA;AAE9F,MAAM,MAAM,eAAe,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,UAAU,EAAE,CAAC;IAAC,EAAE,EAAE,OAAO,CAAA;CAAE,CAAA;AAEzF,MAAM,MAAM,sBAAsB,GAAG;IACnC,sCAAsC;IACtC,EAAE,EAAE,OAAO,CAAA;IACX,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB,iEAAiE;IACjE,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,kFAAkF;IAClF,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,UAAU,EAAE,CAAC;IAAC,OAAO,EAAE,SAAS,EAAE,CAAA;CAAE,CAAA"}

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export { compileGraph, validateGraph, assignStyleSlots, type CompileOptions, typ
 export type { ShaderGraph, GraphNode, GraphLink, ExposedParam, SocketValue, Diagnostic, } from "./graph/schema";
 export { NODE_REGISTRY, type NodeSpec, type SockT } from "./graph/registry";
 export { RENDER_CLASSES, type RenderClass, type AlphaMode, type RenderClassInfo } from "./graph/render-class";
-export type { StyleGroup, GroupDiagnostic, ApplyStyleGroupsResult, ApplyStyleGroupResult, } from "./graph/style-group";
+export type { StyleGroup, GroupImage, GroupImageSource, GroupDiagnostic, ApplyStyleGroupsResult, ApplyStyleGroupResult, } from "./graph/style-group";
 export { HAIR_GRAPH } from "./graph/presets/hair";
 export { DEFAULT_GRAPH } from "./graph/presets/default";
 export { CLOTH_SMOOTH_GRAPH } from "./graph/presets/cloth_smooth";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}