reze-engine 0.17.1 → 0.18.1

package/src/graph/registry.ts

@@ -0,0 +1,351 @@
+// Node registry: one entry per Blender-equivalent node backed by NODES_WGSL (nodes.ts).
+// The registry adds no WGSL of its own — a node type exists here only if its function
+// already exists (validated against EEVEE) in the shader library, or is a WGSL builtin.
+// Semantics are frozen Blender 3.6 legacy-EEVEE; enum modes (math op, mix blend type,
+// ramp interpolation) are part of the type string so they are unambiguously topology.
+
+import type { SocketValue } from "./schema"
+
+export type SockT = "float" | "color" | "vector" | "vec4"
+
+export type InputSpec = {
+  type: SockT
+  default?: SocketValue
+  /** Socket is meaningless as a literal (e.g. the color being processed) — must be linked. */
+  requiresLink?: boolean
+  /** Unlinked fallback is a template local, not a literal (e.g. principled.normal → n). */
+  contextDefault?: string
+}
+
+export type NodeSpec = {
+  inputs: Record<string, InputSpec>
+  outputs: Record<string, SockT>
+  /** RHS expression for this node's `let`, from resolved arg expressions keyed by socket. */
+  emit?: (args: Record<string, string>) => string
+  /** Context nodes tap template locals directly — no `let` emitted. */
+  contextOutputs?: Record<string, string>
+  /** Swizzle applied to the node's variable per output socket (default: none). */
+  outputSelect?: Record<string, string>
+}
+
+// ─── Literal formatting ───────────────────────────────────────────────
+// Deterministic: same graph JSON → byte-identical WGSL. String(x) is JS shortest
+// round-trip, so full-precision Blender constants (0.15000000596046448) survive.
+
+export function fmtFloat(x: number): string {
+  if (!Number.isFinite(x)) throw new Error(`non-finite literal: ${x}`)
+  const s = String(x)
+  return /[.e]/.test(s) ? s : s + ".0"
+}
+
+export function fmtValue(value: SocketValue, type: SockT): string {
+  if (typeof value === "number") {
+    if (type === "float") return fmtFloat(value)
+    if (type === "color" || type === "vector") return `vec3f(${fmtFloat(value)})`
+    return `vec4f(vec3f(${fmtFloat(value)}), 1.0)`
+  }
+  if (value.length === 3) {
+    const [x, y, z] = value
+    if (type === "vec4") return `vec4f(${fmtFloat(x)}, ${fmtFloat(y)}, ${fmtFloat(z)}, 1.0)`
+    if (type === "float") throw new Error(`vector literal on float socket`)
+    // All-equal shorthand matches the hand-written shaders (vec3f(0.167…)).
+    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`)
+  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"
+}
+
+// ─── Implicit socket conversions (Blender-faithful) ──────────────────
+// vec4 appears only on ramp stop-color literals — never linkable, so conversions
+// cover float/color/vector. vector→float is NOT implicit in Blender; rejected.
+
+export function canConvert(from: SockT, to: SockT): boolean {
+  if (from === to) return true
+  if (from === "color" && to === "float") return true // BT.601 via color_to_value
+  if (from === "float" && (to === "color" || to === "vector")) return true
+  if ((from === "color" && to === "vector") || (from === "vector" && to === "color")) return true
+  return false
+}
+
+export function convert(from: SockT, to: SockT, expr: string): string {
+  if (from === to) return expr
+  if (from === "color" && to === "float") return `color_to_value(${expr})`
+  if (from === "float") return `vec3f(${expr})`
+  return expr // color ↔ vector: bit-identical vec3f pass-through
+}
+
+// ─── Registry ─────────────────────────────────────────────────────────
+
+const F = (d: number, requiresLink = false): InputSpec => ({ type: "float", default: d, requiresLink })
+const C = (d: [number, number, number] = [1, 1, 1], requiresLink = false): InputSpec => ({
+  type: "color",
+  default: d,
+  requiresLink,
+})
+const V = (d: [number, number, number] = [0, 0, 0], requiresLink = false): InputSpec => ({
+  type: "vector",
+  default: d,
+  requiresLink,
+})
+const V4 = (d: [number, number, number, number]): InputSpec => ({ type: "vec4", default: d })
+
+const RAMP_INPUTS: Record<string, InputSpec> = {
+  fac: F(0.5, true),
+  pos0: F(0),
+  color0: V4([0, 0, 0, 1]),
+  pos1: F(1),
+  color1: V4([1, 1, 1, 1]),
+}
+const RAMP_OUTPUTS: Record<string, SockT> = { 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" }
+
+export const NODE_REGISTRY: Record<string, NodeSpec> = {
+  // ── Context inputs (template locals; no emission) ──
+  texture: {
+    inputs: {},
+    outputs: { color: "color", alpha: "float" },
+    contextOutputs: { color: "tex_color", alpha: "tex_s.a" },
+  },
+  geometry: {
+    inputs: {},
+    outputs: {
+      normal: "vector",
+      view: "vector",
+      world_pos: "vector",
+      rest_pos: "vector",
+      uv: "vector",
+      // Blender Texture Coordinate → Reflection (view ray mirrored on the normal);
+      // drives env-tracking patterns like metal's voronoi sparkle.
+      reflection: "vector",
+    },
+    contextOutputs: {
+      normal: "n",
+      view: "v",
+      world_pos: "input.worldPos",
+      rest_pos: "input.restPos",
+      uv: "vec3f(input.uv, 0.0)",
+      reflection: "reflect(-v, n)",
+    },
+  },
+
+  // ── 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 },
+
+  // ── Color ──
+  hue_sat: {
+    inputs: { hue: F(0.5), saturation: F(1), value: F(1), fac: F(1), color: C([1, 1, 1], true) },
+    outputs: { color: "color" },
+    emit: (a) => `hue_sat(${a.hue}, ${a.saturation}, ${a.value}, ${a.fac}, ${a.color})`,
+  },
+  bright_contrast: {
+    inputs: { color: C([1, 1, 1], true), bright: F(0), contrast: F(0) },
+    outputs: { color: "color" },
+    emit: (a) => `bright_contrast(${a.color}, ${a.bright}, ${a.contrast})`,
+  },
+  invert: {
+    inputs: { fac: F(1), color: C([1, 1, 1], true) },
+    outputs: { color: "color" },
+    emit: (a) => `invert(${a.fac}, ${a.color})`,
+  },
+  ramp_constant: {
+    inputs: RAMP_INPUTS,
+    outputs: RAMP_OUTPUTS,
+    outputSelect: RAMP_SELECT,
+    emit: (a) => `ramp_constant(${a.fac}, ${a.pos0}, ${a.color0}, ${a.pos1}, ${a.color1})`,
+  },
+  ramp_linear: {
+    inputs: RAMP_INPUTS,
+    outputs: RAMP_OUTPUTS,
+    outputSelect: RAMP_SELECT,
+    emit: (a) => `ramp_linear(${a.fac}, ${a.pos0}, ${a.color0}, ${a.pos1}, ${a.color1})`,
+  },
+  ramp_cardinal: {
+    inputs: RAMP_INPUTS,
+    outputs: RAMP_OUTPUTS,
+    outputSelect: RAMP_SELECT,
+    emit: (a) => `ramp_cardinal(${a.fac}, ${a.pos0}, ${a.color0}, ${a.pos1}, ${a.color1})`,
+  },
+  ramp_constant_aa: {
+    inputs: { fac: F(0.5, true), edge: F(0.5), color0: V4([0, 0, 0, 1]), color1: V4([1, 1, 1, 1]) },
+    outputs: RAMP_OUTPUTS,
+    outputSelect: RAMP_SELECT,
+    emit: (a) => `ramp_constant_edge_aa(${a.fac}, ${a.edge}, ${a.color0}, ${a.color1})`,
+  },
+  // 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.
+  ramp_tri: {
+    inputs: { fac: F(0.5, true) },
+    outputs: { value: "float" },
+    emit: (a) => `1.0 - abs(2.0 * ${a.fac} - 1.0)`,
+  },
+
+  // ── Math (enum op in type string) ──
+  "math/add": { inputs: { a: F(0), b: F(0) }, outputs: { value: "float" }, emit: (a) => `math_add(${a.a}, ${a.b})` },
+  "math/multiply": {
+    inputs: { a: F(0), b: F(0) },
+    outputs: { value: "float" },
+    emit: (a) => `math_multiply(${a.a}, ${a.b})`,
+  },
+  "math/power": {
+    inputs: { a: F(0), b: F(1) },
+    outputs: { value: "float" },
+    emit: (a) => `math_power(${a.a}, ${a.b})`,
+  },
+  "math/greater_than": {
+    inputs: { a: F(0), b: F(0.5) },
+    outputs: { value: "float" },
+    emit: (a) => `math_greater_than(${a.a}, ${a.b})`,
+  },
+  "math/clamp01": { inputs: { a: F(0) }, outputs: { value: "float" }, emit: (a) => `saturate(${a.a})` },
+
+  // ── Mix (blend type in type string) ──
+  "mix/blend": {
+    inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() },
+    outputs: { color: "color" },
+    emit: (a) => `mix_blend(${a.fac}, ${a.a}, ${a.b})`,
+  },
+  "mix/overlay": {
+    inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() },
+    outputs: { color: "color" },
+    emit: (a) => `mix_overlay(${a.fac}, ${a.a}, ${a.b})`,
+  },
+  "mix/multiply": {
+    inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() },
+    outputs: { color: "color" },
+    emit: (a) => `mix_multiply(${a.fac}, ${a.a}, ${a.b})`,
+  },
+  "mix/lighten": {
+    inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() },
+    outputs: { color: "color" },
+    emit: (a) => `mix_lighten(${a.fac}, ${a.a}, ${a.b})`,
+  },
+  "mix/linear_light": {
+    inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() },
+    outputs: { color: "color" },
+    emit: (a) => `mix_linear_light(${a.fac}, ${a.a}, ${a.b})`,
+  },
+  // Emission-add: color + scalar-gated emission. Stand-in for Blender's
+  // Emission → Add Shader pair in the ShaderToRGB era (see hair's bright-tex gate).
+  "mix/add_emit": {
+    inputs: { a: C([0, 0, 0], true), b: F(0) },
+    outputs: { color: "color" },
+    emit: (a) => `${a.a} + vec3f(${a.b})`,
+  },
+  // Blender Emission shader: color × strength. In the ShaderToRGB-era ports the
+  // emission result feeds a Mix Shader directly as radiance. Color may be a literal
+  // (body's rim tints) or linked.
+  emission: {
+    inputs: { color: C([1, 1, 1]), strength: F(1) },
+    outputs: { color: "color" },
+    emit: (a) => `${a.color} * ${a.strength}`,
+  },
+  // Blender Add Shader — radiance sum of two evaluated shading results.
+  add_shader: {
+    inputs: { a: C([0, 0, 0], true), b: C([0, 0, 0], true) },
+    outputs: { color: "color" },
+    emit: (a) => `${a.a} + ${a.b}`,
+  },
+  // Mix Shader — plain lerp between two evaluated shading results.
+  mix_shader: {
+    inputs: { fac: F(0.5), a: C([0, 0, 0], true), b: C([0, 0, 0]) },
+    outputs: { color: "color" },
+    emit: (a) => `mix(${a.a}, ${a.b}, ${a.fac})`,
+  },
+
+  // ── View-dependent scalars ──
+  fresnel: { inputs: { ior: F(1.45) }, outputs: { value: "float" }, emit: (a) => `fresnel(${a.ior}, n, v)` },
+  "layer_weight/fresnel": {
+    inputs: { blend: F(0.5) },
+    outputs: { value: "float" },
+    emit: (a) => `layer_weight_fresnel(${a.blend}, n, v)`,
+  },
+  "layer_weight/facing": {
+    inputs: { blend: F(0.5) },
+    outputs: { value: "float" },
+    emit: (a) => `layer_weight_facing(${a.blend}, n, v)`,
+  },
+
+  // ── Lighting capture ──
+  shader_to_rgb_diffuse: {
+    inputs: {},
+    outputs: { value: "float" },
+    emit: () => `shader_to_rgb_diffuse(n, l, sun, amb, shadow)`,
+  },
+
+  // ── Vector ──
+  separate_xyz: {
+    inputs: { vector: V([0, 0, 0], true) },
+    outputs: { x: "float", y: "float", z: "float" },
+    outputSelect: { x: ".x", y: ".y", z: ".z" },
+    emit: (a) => a.vector,
+  },
+  vect_cross: {
+    // b may be a literal constant (metal crosses the reflection dir with (0,1,0)).
+    inputs: { a: V([0, 0, 0], true), b: V([0, 1, 0]) },
+    outputs: { vector: "vector" },
+    emit: (a) => `vect_math_cross(${a.a}, ${a.b})`,
+  },
+  mapping: {
+    inputs: { vector: V([0, 0, 0], true), loc: V([0, 0, 0]), rot: V([0, 0, 0]), scl: V([1, 1, 1]) },
+    outputs: { vector: "vector" },
+    emit: (a) => `mapping_point(${a.vector}, ${a.loc}, ${a.rot}, ${a.scl})`,
+  },
+  bump: {
+    // Screen-space bump; world position comes from context (matches bump_lh's port).
+    inputs: { strength: F(0.1), height: F(0, true), normal: V([0, 0, 0], true) },
+    outputs: { vector: "vector" },
+    emit: (a) => `bump_lh(${a.strength}, ${a.height}, ${a.normal}, input.worldPos)`,
+  },
+
+  // ── Procedural textures ──
+  tex_noise: {
+    inputs: { vector: V([0, 0, 0], true), scale: F(5), detail: F(2), roughness: F(0.5), distortion: F(0) },
+    outputs: { value: "float" },
+    emit: (a) => `tex_noise(${a.vector}, ${a.scale}, ${a.detail}, ${a.roughness}, ${a.distortion})`,
+  },
+  tex_gradient: {
+    inputs: { vector: V([0, 0, 0], true) },
+    outputs: { value: "float" },
+    emit: (a) => `tex_gradient_linear(${a.vector})`,
+  },
+  "tex_voronoi/f1": {
+    inputs: { vector: V([0, 0, 0], true), scale: F(5) },
+    outputs: { value: "float" },
+    emit: (a) => `tex_voronoi_f1(${a.vector}, ${a.scale})`,
+  },
+  "tex_voronoi/color": {
+    inputs: { vector: V([0, 0, 0], true), scale: F(5) },
+    outputs: { color: "color" },
+    emit: (a) => `tex_voronoi_color(${a.vector}, ${a.scale})`,
+  },
+
+  // ── 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: {
+    inputs: {
+      base: 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),
+      sheen_tint: F(0),
+      normal: { type: "vector", contextDefault: "n" },
+    },
+    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)`,
+  },
+}

package/src/graph/schema.ts

@@ -0,0 +1,60 @@
+// Material style graph — JSON-serializable node graph compiled to WGSL by compile.ts.
+// Engine-space (LH, Y-up): porting a Blender graph converts coordinates at authoring
+// time (Blender Normal Z → engine Y), the compiler never sees Blender conventions.
+// See docs/graph-compiler-spec.md.
+
+import type { MaterialPreset } from "../engine"
+
+export type SocketValue = number | [number, number, number] | [number, number, number, number]
+
+export type GraphNode = {
+  /** Unique within the graph, /^[a-z0-9_]+$/ — becomes the WGSL variable suffix. */
+  id: string
+  /** Node registry key, e.g. "hue_sat", "math/power", "mix/blend". */
+  type: string
+  /** Literal defaults for unlinked input sockets. */
+  inputs?: Record<string, SocketValue>
+  /** Editor-only metadata (React Flow position). Ignored by the compiler, round-tripped
+   *  by serialization so engine-side tooling never strips an editor's layout. */
+  ui?: { position?: { x: number; y: number } }
+}
+
+export type GraphLink = {
+  from: { node: string; socket: string }
+  to: { node: string; socket: string }
+}
+
+/** Adjust-tier slider: overrides one unlinked literal input with a StyleUniforms read. */
+export type ExposedParam = {
+  /** Stable key — slot assignment and serialization identity. */
+  id: string
+  label: string
+  target: { node: string; socket: string }
+  kind: "float" | "color"
+  min?: number
+  max?: number
+  default: SocketValue
+}
+
+export type StyleGraph = {
+  version: 1
+  name: string
+  /** Which preset slot this style targets. The slot owns pass integration (stencil
+   *  variants like hair-over-eyes, alpha semantics, draw order) — always on,
+   *  graph-invisible. The graph only restyles the slot's shading. */
+  slot: MaterialPreset
+  nodes: GraphNode[]
+  links: GraphLink[]
+  /** Must resolve to a color (vec3f) or float (auto-splatted) socket. */
+  output: { node: string; socket: string }
+  params?: ExposedParam[]
+}
+
+export type Diagnostic = {
+  severity: "error" | "warning"
+  nodeId?: string
+  message: string
+}
+
+export const MAX_NODES = 64
+export const MAX_PARAMS = 16

package/src/graph/slots.ts

@@ -0,0 +1,178 @@
+// Per-slot WGSL templates. The graph computes only `final_color`; everything the slot
+// owns — texture sample, MMD alpha semantics, discard, lighting context, FSOut/mask
+// writes, and built-in pass effects like hair's over-eyes stencil variant — lives here,
+// always on, graph-invisible. Mirrors the hand-written material shaders line-for-line.
+
+import { NODES_WGSL } from "../shaders/materials/nodes"
+import { COMMON_MATERIAL_PRELUDE_WGSL } from "../shaders/materials/common"
+import type { MaterialPreset } from "../engine"
+
+export type SlotTemplate = {
+  /** Module-scope declarations (pipeline-override constants, helper fns). */
+  decls: string
+  /** Optional replacement for the standard fs() prelude (custom alpha semantics). */
+  prelude?: string
+  /** Tail of fs(): consumes `final_color` + template locals, writes FSOut. */
+  epilogue: string
+}
+
+const DEFAULT_EPILOGUE = `  var out: FSOut;
+  out.color = vec4f(final_color, alpha);
+  out.mask = vec4f(1.0, 1.0, 0.0, out.color.a);
+  return out;
+`
+
+const DEFAULT_TEMPLATE: SlotTemplate = { decls: "", epilogue: DEFAULT_EPILOGUE }
+
+// Hair's built-in over-eyes effect (see hair.ts): the engine compiles two pipeline
+// variants from the same module — normal opaque hair, and a stencil-matched re-draw
+// at 25% alpha so eyes read through the silhouette. Always on for the hair slot.
+const HAIR_TEMPLATE: SlotTemplate = {
+  decls: `override IS_OVER_EYES: bool = false;
+
+`,
+  epilogue: `  var outAlpha = alpha;
+  if (IS_OVER_EYES) { outAlpha = alpha * 0.25; }
+
+  var out: FSOut;
+  out.color = vec4f(final_color, outAlpha);
+  out.mask = vec4f(1.0, 1.0, 0.0, out.color.a);
+  return out;
+`,
+}
+
+// Stockings' built-in alpha behavior (see stockings.ts): Wyman & McGuire hashed
+// alpha testing on bind-pose restPos replaces the standard threshold discard —
+// sort-independent through self-overlap, dither pinned to the fabric. The graph
+// only computes final_color; the hash gate and the alpha=1 output are slot-owned.
+const STOCKINGS_TEMPLATE: SlotTemplate = {
+  decls: `fn _hash3d_wm(a: vec3f) -> f32 {
+  return _hash33(a).x * 0.5 + 0.5;
+}
+fn hashed_alpha_threshold(co: vec3f) -> f32 {
+  let alphaHashScale: f32 = 1.0;
+  let max_deriv = max(length(dpdx(co)), length(dpdy(co)));
+  let pix_scale = 1.0 / max(alphaHashScale * max_deriv, 1e-6);
+  let pix_scale_log = log2(pix_scale);
+  let px_lo = exp2(floor(pix_scale_log));
+  let px_hi = exp2(ceil(pix_scale_log));
+  let a_lo = _hash3d_wm(floor(px_lo * co));
+  let a_hi = _hash3d_wm(floor(px_hi * co));
+  let fac = fract(pix_scale_log);
+  let x = mix(a_lo, a_hi, fac);
+  let a = min(fac, 1.0 - fac);
+  let one_a = 1.0 - a;
+  let denom = 1.0 / max(2.0 * a * one_a, 1e-6);
+  let one_x = 1.0 - x;
+  let case_lo = (x * x) * denom;
+  let case_mid = (x - 0.5 * a) / max(one_a, 1e-6);
+  let case_hi = 1.0 - (one_x * one_x) * denom;
+  var threshold = select(case_hi, select(case_lo, case_mid, x >= a), x < one_a);
+  return clamp(threshold, 1e-6, 1.0);
+}
+
+`,
+  prelude: `@fragment fn fs(input: VertexOutput) -> FSOut {
+  let tex_s = textureSample(diffuseTexture, diffuseSampler, input.uv);
+  // Hashed alpha test (EEVEE "Hashed" blend) instead of the standard threshold.
+  let alpha = material.alpha * tex_s.a;
+  if (alpha < hashed_alpha_threshold(input.restPos)) { discard; }
+
+  let n = safe_normal(input.normal);
+  let v = normalize(camera.viewPos - input.worldPos);
+  let l = -light.lights[0].direction.xyz;
+  let sun = light.lights[0].color.xyz * light.lights[0].color.w;
+  let amb = light.ambientColor.xyz;
+  let shadow = sampleShadow(input.worldPos, n);
+  let tex_color = tex_s.rgb;
+
+`,
+  epilogue: `  var out: FSOut;
+  out.color = vec4f(final_color, 1.0);
+  out.mask = vec4f(1.0, 1.0, 0.0, out.color.a);
+  return out;
+`,
+}
+
+// Eye's built-in rear-view gate (see eye.ts): open-shell PMX heads don't occlude
+// the eye from behind, so it would draw (and stamp the see-through stencil) through
+// the back of the head. Gate by camera-vs-face hemisphere via the 頭 bone's skinning
+// matrix. Discarding here drops color, depth, and the stencil stamp together. The
+// stencil-stamp pipeline state + front-face cull are slot-owned in createSlotPipeline;
+// the graph only computes the eye's shading (Principled + emission).
+const EYE_TEMPLATE: SlotTemplate = {
+  decls: "",
+  prelude: `@fragment fn fs(input: VertexOutput) -> FSOut {
+  let tex_s = textureSample(diffuseTexture, diffuseSampler, input.uv);
+  let alpha = material.alpha * tex_s.a;
+  if (alpha < 0.001) { discard; }
+
+  let n = safe_normal(input.normal);
+  let v = normalize(camera.viewPos - input.worldPos);
+
+  if (material.headBoneIndex >= 0.0) {
+    let hm = skinMats[u32(material.headBoneIndex)];
+    let faceDir = -normalize(hm[2].xyz);
+    if (dot(faceDir, v) < -0.15) { discard; }
+  }
+
+  let l = -light.lights[0].direction.xyz;
+  let sun = light.lights[0].color.xyz * light.lights[0].color.w;
+  let amb = light.ambientColor.xyz;
+  let shadow = sampleShadow(input.worldPos, n);
+  let tex_color = tex_s.rgb;
+
+`,
+  epilogue: DEFAULT_EPILOGUE,
+}
+
+export const SLOT_TEMPLATES: Partial<Record<MaterialPreset, SlotTemplate>> = {
+  hair: HAIR_TEMPLATE,
+  stockings: STOCKINGS_TEMPLATE,
+  eye: EYE_TEMPLATE,
+}
+
+export function slotTemplate(slot: MaterialPreset): SlotTemplate {
+  return SLOT_TEMPLATES[slot] ?? DEFAULT_TEMPLATE
+}
+
+// Adjust-tier uniforms — fixed 16-vec4f block (256 B) so the single shared material
+// bind group layout serves every graph; non-graph presets bind a zero buffer.
+export const STYLE_UNIFORMS_WGSL = `struct StyleUniforms { p: array<vec4f, 16> };
+@group(2) @binding(4) var<uniform> style: StyleUniforms;
+
+`
+
+// fs() prelude — identical to the hand-written materials so template locals keep the
+// exact names the registry's context nodes and emit functions reference.
+const FS_PRELUDE = `@fragment fn fs(input: VertexOutput) -> FSOut {
+  let tex_s = textureSample(diffuseTexture, diffuseSampler, input.uv);
+  // MMD alpha semantics: material alpha × texture alpha (hair/lace textures cut
+  // their shapes in the alpha channel).
+  let alpha = material.alpha * tex_s.a;
+  if (alpha < 0.001) { discard; }
+
+  let n = safe_normal(input.normal);
+  let v = normalize(camera.viewPos - input.worldPos);
+  let l = -light.lights[0].direction.xyz;
+  let sun = light.lights[0].color.xyz * light.lights[0].color.w;
+  let amb = light.ambientColor.xyz;
+  let shadow = sampleShadow(input.worldPos, n);
+  let tex_color = tex_s.rgb;
+
+`
+
+export function assembleModule(slot: MaterialPreset, fsBody: string, includeStyleUniforms: boolean): string {
+  const tmpl = slotTemplate(slot)
+  return (
+    NODES_WGSL +
+    COMMON_MATERIAL_PRELUDE_WGSL +
+    (includeStyleUniforms ? STYLE_UNIFORMS_WGSL : "") +
+    tmpl.decls +
+    (tmpl.prelude ?? FS_PRELUDE) +
+    fsBody +
+    "\n" +
+    tmpl.epilogue +
+    "}\n"
+  )
+}

package/src/index.ts

@@ -10,11 +10,38 @@ export {
   type MaterialPreset,
   type ResolvedMaterialPreset,
   type MaterialPresetMap,
+  type ApplyStyleResult,
   type GizmoDragEvent,
   type GizmoDragCallback,
   type GizmoDragKind,
 } from "./engine"
 export { parsePmxFolderInput, pmxFileAtRelativePath, type PmxFolderInputResult } from "./folder-upload"
+export {
+  compileGraph,
+  validateGraph,
+  assignStyleSlots,
+  type CompileOptions,
+  type CompileResult,
+  type StyleSlot,
+} from "./graph/compile"
+export type {
+  StyleGraph,
+  GraphNode,
+  GraphLink,
+  ExposedParam,
+  SocketValue,
+  Diagnostic,
+} from "./graph/schema"
+export { NODE_REGISTRY, type NodeSpec, type SockT } from "./graph/registry"
+export { HAIR_GRAPH } from "./graph/presets/hair"
+export { DEFAULT_GRAPH } from "./graph/presets/default"
+export { CLOTH_SMOOTH_GRAPH } from "./graph/presets/cloth_smooth"
+export { CLOTH_ROUGH_GRAPH } from "./graph/presets/cloth_rough"
+export { METAL_GRAPH } from "./graph/presets/metal"
+export { BODY_GRAPH } from "./graph/presets/body"
+export { STOCKINGS_GRAPH } from "./graph/presets/stockings"
+export { EYE_GRAPH } from "./graph/presets/eye"
+export { FACE_GRAPH } from "./graph/presets/face"
 export { Model } from "./model"
 export { Vec3, Quat, Mat4 } from "./math"
 export type {

package/dist/physics-debug.d.ts

@@ -1,30 +0,0 @@
-import type { RezePhysics } from "./physics";
-export declare class PhysicsDebugRenderer {
-    private device;
-    private bindGroup;
-    private wirePipelineSphere;
-    private wirePipelineBox;
-    private wirePipelineCapsule;
-    private wireSphereBuffer;
-    private wireBoxBuffer;
-    private wireCapsuleBuffer;
-    private wireSphereCount;
-    private wireBoxCount;
-    private wireCapsuleCount;
-    private solidPipelineSphere;
-    private solidPipelineBox;
-    private solidPipelineCapsule;
-    private solidSphereBuffer;
-    private solidBoxBuffer;
-    private solidCapsuleBuffer;
-    private solidSphereCount;
-    private solidBoxCount;
-    private solidCapsuleCount;
-    private instanceBuffer;
-    private instanceData;
-    private instanceCapacity;
-    constructor(device: GPUDevice, cameraUniformBuffer: GPUBuffer, presentationFormat: GPUTextureFormat);
-    render(pass: GPURenderPassEncoder, physics: RezePhysics): void;
-    destroy(): void;
-}
-//# sourceMappingURL=physics-debug.d.ts.map

package/dist/physics-debug.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"physics-debug.d.ts","sourceRoot":"","sources":["../src/physics-debug.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAmB5C,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,SAAS,CAAc;IAG/B,OAAO,CAAC,kBAAkB,CAAmB;IAC7C,OAAO,CAAC,eAAe,CAAmB;IAC1C,OAAO,CAAC,mBAAmB,CAAmB;IAC9C,OAAO,CAAC,gBAAgB,CAAW;IACnC,OAAO,CAAC,aAAa,CAAW;IAChC,OAAO,CAAC,iBAAiB,CAAW;IACpC,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,gBAAgB,CAAQ;IAIhC,OAAO,CAAC,mBAAmB,CAAmB;IAC9C,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,oBAAoB,CAAmB;IAC/C,OAAO,CAAC,iBAAiB,CAAW;IACpC,OAAO,CAAC,cAAc,CAAW;IACjC,OAAO,CAAC,kBAAkB,CAAW;IACrC,OAAO,CAAC,gBAAgB,CAAQ;IAChC,OAAO,CAAC,aAAa,CAAQ;IAC7B,OAAO,CAAC,iBAAiB,CAAQ;IAEjC,OAAO,CAAC,cAAc,CAAW;IACjC,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,gBAAgB,CAAQ;gBAG9B,MAAM,EAAE,SAAS,EACjB,mBAAmB,EAAE,SAAS,EAC9B,kBAAkB,EAAE,gBAAgB;IA2HtC,MAAM,CAAC,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI;IAmI9D,OAAO,IAAI,IAAI;CAShB"}