reze-engine 0.41.0 → 0.41.2

package/src/graph/presets/face.ts

@@ -73,7 +73,7 @@ export const FACE_GRAPH: ShaderGraph = {
     {
       id: "principled",
       type: "principled",
-      inputs: { metallic: 0.0, specular: 0.5, roughness: 0.3, spec_clamp: 10.0, sheen: 0.0, sheen_tint: 0.0 },
+      inputs: { metallic: 0.0, specular_ior_level: 0.5, roughness: 0.3, spec_clamp: 10.0, sheen_weight: 0.0, sheen_tint: 0.0 },
     },
     { id: "p_sum", type: "add_shader" },
 
@@ -124,7 +124,7 @@ export const FACE_GRAPH: ShaderGraph = {
     { from: { node: "noise_ramp", socket: "fac_out" }, to: { node: "principled_base", socket: "fac" } },
     { from: { node: "bc", socket: "color" }, to: { node: "principled_base", socket: "a" } },
     { from: { node: "bc", socket: "color" }, to: { node: "p_emit", socket: "color" } },
-    { from: { node: "principled_base", socket: "color" }, to: { node: "principled", socket: "base" } },
+    { from: { node: "principled_base", socket: "color" }, to: { node: "principled", socket: "base_color" } },
     { from: { node: "bump", socket: "vector" }, to: { node: "principled", socket: "normal" } },
     { from: { node: "principled", socket: "color" }, to: { node: "p_sum", socket: "a" } },
     { from: { node: "p_emit", socket: "color" }, to: { node: "p_sum", socket: "b" } },

package/src/graph/presets/hair.ts

@@ -44,7 +44,7 @@ export const HAIR_GRAPH: ShaderGraph = {
     {
       id: "principled",
       type: "principled",
-      inputs: { metallic: 0.0, specular: 1.0, roughness: 0.3, spec_clamp: 10.0, sheen: 0.0, sheen_tint: 0.0 },
+      inputs: { metallic: 0.0, specular_ior_level: 1.0, roughness: 0.3, spec_clamp: 10.0, sheen_weight: 0.0, sheen_tint: 0.0 },
     },
     { id: "mix_shader_001", type: "mix_shader", inputs: { fac: 0.2 } },
   ],
@@ -71,7 +71,7 @@ export const HAIR_GRAPH: ShaderGraph = {
     { from: { node: "gate", socket: "value" }, to: { node: "gate_scale", socket: "a" } },
     { from: { node: "mix_shader_002", socket: "color" }, to: { node: "npr_add", socket: "a" } },
     { from: { node: "gate_scale", socket: "value" }, to: { node: "npr_add", socket: "b" } },
-    { from: { node: "bc", socket: "color" }, to: { node: "principled", socket: "base" } },
+    { from: { node: "bc", socket: "color" }, to: { node: "principled", socket: "base_color" } },
     { from: { node: "npr_add", socket: "color" }, to: { node: "mix_shader_001", socket: "a" } },
     { from: { node: "principled", socket: "color" }, to: { node: "mix_shader_001", socket: "b" } },
   ],

package/src/graph/presets/metal.ts

@@ -30,7 +30,7 @@ export const METAL_GRAPH: ShaderGraph = {
     {
       id: "principled",
       type: "principled",
-      inputs: { metallic: 1.0, specular: 1.0, roughness: 0.3, spec_clamp: 1e30, sheen: 0.0, sheen_tint: 0.0 },
+      inputs: { metallic: 1.0, specular_ior_level: 1.0, roughness: 0.3, spec_clamp: 1e30, sheen_weight: 0.0, sheen_tint: 0.0 },
     },
     { id: "mix_shader_001", type: "mix_shader", inputs: { fac: 0.6967 } },
   ],
@@ -53,7 +53,7 @@ export const METAL_GRAPH: ShaderGraph = {
     { from: { node: "voro_ramp", socket: "fac_out" }, to: { node: "albedo", socket: "fac" } },
     { from: { node: "voro_ramp", socket: "fac_out" }, to: { node: "albedo", socket: "a" } },
     { from: { node: "hue_006", socket: "color" }, to: { node: "albedo", socket: "b" } },
-    { from: { node: "albedo", socket: "color" }, to: { node: "principled", socket: "base" } },
+    { from: { node: "albedo", socket: "color" }, to: { node: "principled", socket: "base_color" } },
     { from: { node: "npr_emit", socket: "color" }, to: { node: "mix_shader_001", socket: "a" } },
     { from: { node: "principled", socket: "color" }, to: { node: "mix_shader_001", socket: "b" } },
   ],

package/src/graph/presets/stockings.ts

@@ -29,10 +29,10 @@ export const STOCKINGS_GRAPH: ShaderGraph = {
       type: "principled",
       inputs: {
         metallic: 0.1,
-        specular: 1.0,
+        specular_ior_level: 1.0,
         roughness: 0.5,
         spec_clamp: 1e30,
-        sheen: 0.7017999887466431,
+        sheen_weight: 0.7017999887466431,
         sheen_tint: 0.5,
       },
     },
@@ -48,7 +48,7 @@ export const STOCKINGS_GRAPH: ShaderGraph = {
     { from: { node: "mix_001", socket: "color" }, to: { node: "mask", socket: "a" } },
     { from: { node: "ramp_002", socket: "fac_out" }, to: { node: "mask", socket: "b" } },
     { from: { node: "tex", socket: "color" }, to: { node: "emission_hs", socket: "color" } },
-    { from: { node: "tex", socket: "color" }, to: { node: "principled", socket: "base" } },
+    { from: { node: "tex", socket: "color" }, to: { node: "principled", socket: "base_color" } },
     { from: { node: "emission_hs", socket: "color" }, to: { node: "mix_shader_001", socket: "a" } },
     { from: { node: "principled", socket: "color" }, to: { node: "mix_shader_001", socket: "b" } },
     { from: { node: "mask", socket: "color" }, to: { node: "mix_shader_001", socket: "fac" } },

package/src/graph/registry.ts

@@ -52,15 +52,19 @@ export function fmtValue(value: SocketValue, type: SockT): string {
     if (x === y && y === z) return `vec3f(${fmtFloat(x)})`
     return `vec3f(${fmtFloat(x)}, ${fmtFloat(y)}, ${fmtFloat(z)})`
   }
-  if (type !== "vec4") throw new Error(`vec4 literal on ${type} socket`)
+  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") 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: SocketValue, type: SockT): boolean {
   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) ──────────────────
@@ -109,6 +113,18 @@ const RAMP_OUTPUTS: Record<string, SockT> = { color: "color", alpha: "float", fa
 // 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: string, level: string): string {
+  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: Record<string, NodeSpec> = {
   // ── Context inputs (template locals; no emission) ──
   texture: {
@@ -137,6 +153,44 @@ export const NODE_REGISTRY: Record<string, NodeSpec> = {
       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.
@@ -157,6 +211,267 @@ export const NODE_REGISTRY: Record<string, NodeSpec> = {
     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 },
@@ -201,8 +516,28 @@ export const NODE_REGISTRY: Record<string, NodeSpec> = {
     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" },
@@ -296,12 +631,37 @@ export const NODE_REGISTRY: Record<string, NodeSpec> = {
   },
 
   // ── 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) },
@@ -352,19 +712,88 @@ export const NODE_REGISTRY: Record<string, NodeSpec> = {
   // ── 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: string, sockets: Record<string, InputSpec>): void {
+  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/src/graph/style-group.ts

@@ -22,8 +22,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; diagnostics: Diagnostic[]; ok: boolean }
 
 export type ApplyStyleGroupsResult = {