reze-engine 0.66.5 → 0.67.0

package/src/engine.ts

@@ -79,7 +79,14 @@ import {
 } from "./shaders/lights"
 import { buildLightGrid } from "./light-grid"
 import { groundShaderWgsl, GROUND_NOISE_BAKE_WGSL, GROUND_NOISE_SIZE } from "./shaders/passes/ground"
-import { outlineShaderWgsl, RZ_OUTLINE_COLOR_OFFSET, RZ_OUTLINE_DISSOLVE_OFFSET, RZ_OUTLINE_WIDTH_OFFSET } from "./shaders/passes/outline"
+import {
+  outlineShaderWgsl,
+  RZ_OUTLINE_COLOR_OFFSET,
+  RZ_OUTLINE_DISSOLVE_OFFSET,
+  RZ_OUTLINE_SHADOW_OFFSET,
+  RZ_OUTLINE_TEXTURED_OFFSET,
+  RZ_OUTLINE_WIDTH_OFFSET,
+} from "./shaders/passes/outline"
 import { transparentDepthPrepassWgsl } from "./shaders/passes/depth-prepass"
 import { SELECTION_MASK_SHADER_WGSL, SELECTION_EDGE_SHADER_WGSL } from "./shaders/passes/selection"
 import { GIZMO_SHADER_WGSL } from "./shaders/passes/gizmo"
@@ -238,7 +245,7 @@ const PRESET_NAME_HINTS: Array<[MaterialPreset, string[]]> = [
       "hair", "ahoge", "bang",
     ],
   ],
-  ["body", ["肌", "皮肤", "skin"]],
+  ["body", ["肌", "皮肤", "skin", "指甲", "nail"]],
   ["metal", ["金属", "メタル", "metal", "earring", "耳环", "耳環"]],
   [
     "cloth_smooth",
@@ -284,6 +291,11 @@ const PRESET_NAME_HINTS: Array<[MaterialPreset, string[]]> = [
   ],
 ]
 
+// Whole names that are body parts — skin by another name. Whole, never
+// substrings: 手 alone is a hand, inside 手套 (gloves) or 手镯 (a bracelet) it is
+// what the hand wears; 足 is a leg, 足袋 a sock.
+const BODY_PART_NAMES = new Set(["手", "手部", "腕", "足", "脚", "腿", "爪", "hand", "hands", "arm", "arms", "leg", "legs", "body"])
+
 // Resolve a material name to a style category (override map first, then name hints), or
 // null if nothing matches — a null-resolving material stays ungrouped (neutral default).
 function resolvePreset(materialName: string, map: MaterialPresetMap | undefined): MaterialPreset | null {
@@ -293,6 +305,7 @@ function resolvePreset(materialName: string, map: MaterialPresetMap | undefined)
     }
   }
   const lower = materialName.toLowerCase()
+  if (BODY_PART_NAMES.has(lower.replace(/[\s_.\-0-9]+$/, ""))) return "body"
   for (const [preset, hints] of PRESET_NAME_HINTS) {
     for (const hint of hints) {
       if (lower.includes(hint)) return preset
@@ -641,10 +654,16 @@ export type ViewTransformOptions = {
   exposure: number
   /** After the transform, display gamma (`pow(rgb, 1/gamma)`). */
   gamma: number
+  /**
+   * The "soft" curve's power, (1 - e^(-2.5x))^contrast. Aether Gazer sets it per
+   * scene (SceneSetting._contrast): 1.4 is its common value, the character page
+   * runs 1.7. A stage brings its own; the other transforms ignore it.
+   */
+  contrast: number
   /**
    * Which display transform the frame is formed with (composite.ts, viewTransform).
    *
-   * "soft" — Aether Gazer's own final curve, (1 - e^(-2.5x))^1.4. The default.
+   * "soft" — Aether Gazer's own final curve, (1 - e^(-2.5x))^contrast. The default.
    * "neutral" — Unity URP's Neutral, the Khronos PBR Neutral operator: colour
    *   passes through until the top fifth, which rolls off.
    * "aces" — Unity URP's ACES (RRT + ODT approximation from the Core RP).
@@ -660,6 +679,7 @@ export type ViewTransformName = "soft" | "neutral" | "aces" | "none"
 export const DEFAULT_VIEW_TRANSFORM: ViewTransformOptions = {
   exposure: 0,
   gamma: 1.0,
+  contrast: 1.4,
   transform: "soft",
 }
 
@@ -823,7 +843,9 @@ interface DrawCall {
   /** Edge-flagged materials: interleaved inverted-hull outline drawn right after
    *  this material with the outline pipeline. Shares this call's index range;
    *  own bind group (edge uniforms + diffuse texture for the alpha test). */
-  outline?: { bindGroup: GPUBindGroup }
+  /** The inverted hull: `pmx` when the PMX asked for an edge, `drawn` when it
+   *  is drawn — the PMX's, or its style group's look's outline. */
+  outline?: { bindGroup: GPUBindGroup; pmx: boolean; drawn: boolean }
   /** MODEL-SPACE AABB over this material's index range, computed at load:
    *  [minX, minY, minZ, maxX, maxY, maxZ]. Usable for culling only while the
    *  owning model is rigid (see ModelInstance.rigid) — animation moves vertices
@@ -930,6 +952,9 @@ interface ModelInstance {
    *  material buffers never reached it and a dissolved character kept her
    *  outline. Kept here so that write has somewhere to go. */
   outlineUniformBuffers: GPUBuffer[]
+  /** Each outlined material's hull block and its PMX edge (colour, size), for
+   *  a style graph's outline to take over and give back. */
+  outlineByMaterial: Map<string, { buffer: GPUBuffer; edge: Float32Array<ArrayBuffer>; picture: GPUTextureView }>
   model: Model
   /**
    * Keep simulating this model's cloth while it is HIDDEN.
@@ -2632,7 +2657,7 @@ export class Engine {
   // 15 × vec4f — see the viewU comment in composite.ts. The last one is the
   // camera's world position, which is what lets a foreground effect turn the
   // depth it is handed into a PLACE (bgWorldPos) rather than a distance.
-  private readonly compositeUniformData = new Float32Array(60)
+  private readonly compositeUniformData = new Float32Array(64)
   /** Composite background (display-space sRGB 0–1) — null = transparent canvas. */
   private backgroundColor: Vec3 | null = null
   // 360 backdrop (equirectangular skybox, sampled by view ray in composite).
@@ -3054,6 +3079,7 @@ export class Engine {
     return {
       exposure: partial?.exposure ?? d.exposure,
       gamma: partial?.gamma ?? d.gamma,
+      contrast: partial?.contrast ?? d.contrast,
       transform: partial?.transform ?? d.transform,
     }
   }
@@ -3072,7 +3098,7 @@ export class Engine {
 
   getViewTransformOptions(): ViewTransformOptions {
     const v = this.viewTransform
-    return { exposure: v.exposure, gamma: v.gamma, transform: v.transform }
+    return { exposure: v.exposure, gamma: v.gamma, contrast: v.contrast, transform: v.transform }
   }
 
   private colorGrading: ColorGradingOptions = {
@@ -3188,6 +3214,7 @@ export class Engine {
     const v = this.viewTransform
     if (patch.exposure !== undefined) v.exposure = patch.exposure
     if (patch.gamma !== undefined) v.gamma = patch.gamma
+    if (patch.contrast !== undefined) v.contrast = patch.contrast
     if (patch.transform !== undefined) v.transform = patch.transform
     if (this.device && this.compositeUniformBuffer) {
       this.writeCompositeViewUniforms()
@@ -3266,6 +3293,9 @@ export class Engine {
     u[25] = Engine.VIEW_TRANSFORM_ID[v.transform] ?? 0
     u[26] = this.canvas.width
     u[27] = this.canvas.height
+    // The soft curve's power (viewU[15].x), the scene's own (SceneSetting._contrast).
+    // Its own vec4: viewU[11..14] are the cast's positions whenever an effect runs.
+    u[60] = v.contrast
     // ── Grade (viewU[7..9]) ── The UI's three tonal COLORS map to ASC CDL here,
     // on the CPU, so the shader only ever sees slope/offset/power. Mid-gray is
     // neutral in all three; the signed distance from it is the amount.
@@ -8468,6 +8498,8 @@ export class Engine {
       entries: [
         { binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
         { binding: 1, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } },
+        // the key light, for a style graph's outline colour (see outline.ts)
+        { binding: 2, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
       ],
     })
     // Outline per-instance reuses mainPerInstanceBindGroupLayout (same skinMats binding)
@@ -8476,6 +8508,7 @@ export class Engine {
       entries: [
         { binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
         { binding: 1, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float" } },
+        { binding: 2, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float" } },
       ],
     })
 
@@ -8494,6 +8527,7 @@ export class Engine {
       entries: [
         { binding: 0, resource: { buffer: this.cameraUniformBuffer } },
         { binding: 1, resource: this.materialSampler },
+        { binding: 2, resource: { buffer: this.lightUniformBuffer } },
       ],
     })
 
@@ -8507,6 +8541,7 @@ export class Engine {
       entries: [
         { binding: 0, resource: { buffer: this.mirrorCameraBuffer } },
         { binding: 1, resource: this.materialSampler },
+        { binding: 2, resource: { buffer: this.lightUniformBuffer } },
       ],
     })
 
@@ -8694,13 +8729,14 @@ export class Engine {
     // strength belong to the combine step.
     this.compositeUniformBuffer = this.device.createBuffer({
       label: "composite view uniforms",
-      // 15 × vec4f: (exposure, invGamma, _, _) · (bloom tint, intensity) ·
+      // 16 × vec4f: (exposure, invGamma, _, _) · (bloom tint, intensity) ·
       // (bg rgb, mode) · camera right/up/forward basis for the 360 skybox ray ·
       // (time, _, canvas width, canvas height) for user effects · three grade
       // vectors (CDL offset+contrast, power+saturation, slope+flag) · camera
       // world position, for an effect placing itself in the scene · four
-      // character positions, for one that wants to respond to the cast.
-      size: 240,
+      // character positions, for one that wants to respond to the cast · the
+      // soft curve's contrast. Shaders that stop at the cast declare 15.
+      size: 256,
       usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
     })
     this.dofUniformBuffer = this.device.createBuffer({
@@ -14894,6 +14930,7 @@ export class Engine {
       dissolve: 1,
       materialUniformBuffers: [],
       outlineUniformBuffers: [],
+      outlineByMaterial: new Map(),
       cullModelIndex: 0,
       // Seeded false: the first skin-matrix upload decides it, and until then the
       // sphere path is the safe answer (it never culls something it should not).
@@ -15535,8 +15572,12 @@ export class Engine {
       // every material — on the heaviest mesh in the scene that doubles the
       // geometry submitted per frame to draw cartoon outlines around
       // architecture, which is not the look anyone is after.
+      // Every character material gets its hull: the PMX edge flag draws it as
+      // MMD does, and a style group whose look carries an outline draws it on
+      // any material (assignDrawCallGroups sets `drawn`).
       let outline: DrawCall["outline"]
-      if (!inst.isStage && (mat.edgeFlag & 0x10) !== 0 && mat.edgeSize > 0) {
+      const pmxEdge = (mat.edgeFlag & 0x10) !== 0 && mat.edgeSize > 0
+      if (!inst.isStage) {
         const materialUniformData = new Float32Array([
           mat.edgeColor[0],
           mat.edgeColor[1],
@@ -15551,25 +15592,29 @@ export class Engine {
           1,
           // The scene's width multiplier, at RZ_OUTLINE_WIDTH_OFFSET.
           this.outlineWidth,
+          // A style graph's outline, at RZ_OUTLINE_TEXTURED_OFFSET: none yet.
           0,
           // The scene's colour override, at RZ_OUTLINE_COLOR_OFFSET.
           this.outlineColor[0],
           this.outlineColor[1],
           this.outlineColor[2],
           this.outlineColor[3],
+          // The graph outline's shadow colour, at RZ_OUTLINE_SHADOW_OFFSET.
+          0,
+          0,
+          0,
+          0,
         ])
         const outlineUniformBuffer = this.createUniformBuffer(`${prefix}outline: ${mat.name}`, materialUniformData)
         inst.gpuBuffers.push(outlineUniformBuffer)
         inst.outlineUniformBuffers.push(outlineUniformBuffer)
-        const outlineBindGroup = this.device.createBindGroup({
-          label: `${prefix}outline: ${mat.name}`,
-          layout: this.outlinePerMaterialBindGroupLayout,
-          entries: [
-            { binding: 0, resource: { buffer: outlineUniformBuffer } },
-            { binding: 1, resource: textureView },
-          ],
+        inst.outlineByMaterial.set(mat.name, {
+          buffer: outlineUniformBuffer,
+          edge: materialUniformData.slice(0, 5),
+          picture: textureView,
         })
-        outline = { bindGroup: outlineBindGroup }
+        const outlineBindGroup = this.outlineBindGroup(`${prefix}outline: ${mat.name}`, outlineUniformBuffer, textureView, null)
+        outline = { bindGroup: outlineBindGroup, pmx: pmxEdge, drawn: pmxEdge }
         if (!inst.outlineVertexBuffer) {
           const data = inst.model.getOutlineVertices()
           const buf = this.device.createBuffer({
@@ -18109,8 +18154,45 @@ export class Engine {
 
   // Rebind each material draw call to its (successfully-installed) group's uniform buffer,
   // or the zero buffer when ungrouped, then re-sort by render-class draw order.
+  /** A hull's per-material group: its block, the picture, the look's tint. */
+  private outlineBindGroup(label: string, buffer: GPUBuffer, picture: GPUTextureView, tint: GPUTexture | null): GPUBindGroup {
+    return this.device.createBindGroup({
+      label,
+      layout: this.outlinePerMaterialBindGroupLayout,
+      entries: [
+        { binding: 0, resource: { buffer } },
+        { binding: 1, resource: picture },
+        { binding: 2, resource: (tint ?? this.fallbackMaterialTexture).createView() },
+      ],
+    })
+  }
+
   private assignDrawCallGroups(inst: ModelInstance, claimed: Map<string, string>): void {
     inst.materialToGroup.clear()
+    // The hulls: a group whose look carries an outline (ShaderGraph.outline)
+    // draws it in place of the PMX edge; the rest keep, or get back, their own.
+    for (const [name, hull] of inst.outlineByMaterial) {
+      const id = claimed.get(name)
+      const install = id ? inst.styleGroups.get(id) : undefined
+      const o = install?.group.graph.outline
+      const block = o
+        ? new Float32Array([o.color[0], o.color[1], o.color[2], 1, o.width])
+        : hull.edge
+      this.device.queue.writeBuffer(hull.buffer, 0, block)
+      this.device.queue.writeBuffer(hull.buffer, RZ_OUTLINE_TEXTURED_OFFSET, new Float32Array([o ? 1 : 0]))
+      if (o) this.device.queue.writeBuffer(hull.buffer, RZ_OUTLINE_SHADOW_OFFSET, new Float32Array([...o.shadowColor, 1]))
+      const tint = o?.tint != null ? (install?.imagesByMaterial?.[name] ?? install?.images)?.[o.tint] ?? null : null
+      for (const dc of inst.drawCalls) {
+        if (dc.materialName !== name || !dc.outline) continue
+        dc.outline.bindGroup = this.outlineBindGroup(`outline: ${name}`, hull.buffer, hull.picture, tint)
+        this.bundlesDirty = true
+        const drawn = o ? o.width > 0 : dc.outline.pmx
+        if (dc.outline.drawn !== drawn) {
+          dc.outline.drawn = drawn
+          this.bundlesDirty = true
+        }
+      }
+    }
     for (const dc of inst.drawCalls) {
       if (!dc.baseBindGroupEntries) continue // outlines/ground are never grouped
       const wantId = claimed.get(dc.materialName)
@@ -18609,7 +18691,7 @@ export class Engine {
       }
       pass.setBindGroup(2, draw.bindGroup)
       this.issueDraw(pass, draw, view.args)
-      if (draw.outline && this.outlineEnabled && view.outlines) outlined.push(draw)
+      if (draw.outline?.drawn && this.outlineEnabled && view.outlines) outlined.push(draw)
     }
     // THE HULLS AFTER THE SURFACES, as MMD draws a model's edges. A hull held
     // at the minimum width is faded, and it still writes depth: drawn between

package/src/graph/presets/body.ts

@@ -24,7 +24,7 @@ export const BODY_GRAPH: ShaderGraph = {
     { id: "lit_tint", type: "hue_sat", inputs: { hue: 0.5, saturation: 1.5, value: 1.0, fac: 1.0 } },
     { id: "toon_color", type: "mix/blend" },
     { id: "bc", type: "bright_contrast", inputs: { bright: 0.1, contrast: 0.2 } },
-    { id: "emission3", type: "vector_math/scale", inputs: { scale: 4.0 } },
+    { id: "emission3", type: "vector_math/scale", inputs: { scale: 3.2 } },
     { id: "warm_add", type: "math/add", inputs: { b: 0.5 } },
     { id: "warm_clamp", type: "math/clamp01" },
     {

package/src/graph/presets/cloth_rough.ts

@@ -30,7 +30,7 @@ export const CLOTH_ROUGH_GRAPH: ShaderGraph = {
     { id: "mix_003", type: "mix/blend" },
     { id: "hue_004", type: "hue_sat", inputs: { hue: 0.5, saturation: 0.800000011920929, value: 2.0, fac: 1.0 } },
     { id: "npr_overlay", type: "mix/overlay", inputs: { fac: 1.0 } },
-    { id: "npr_emit", type: "vector_math/scale", inputs: { scale: 18.200000762939453 } },
+    { id: "npr_emit", type: "vector_math/scale", inputs: { scale: 14.56 } },
     { id: "noise", type: "tex_noise", inputs: { scale: 17.7 } },
     { id: "noise_ramp", type: "ramp_linear", inputs: { pos0: 0.0, pos1: 1.0 } },
     { id: "bump", type: "bump", inputs: { strength: 1.0 } },

package/src/graph/presets/cloth_smooth.ts

@@ -28,7 +28,7 @@ export const CLOTH_SMOOTH_GRAPH: ShaderGraph = {
     { id: "mix_003", type: "mix/blend" },
     { id: "hue_004", type: "hue_sat", inputs: { hue: 0.5, saturation: 0.800000011920929, value: 2.0, fac: 1.0 } },
     { id: "npr_overlay", type: "mix/overlay", inputs: { fac: 1.0 } },
-    { id: "npr_emit", type: "vector_math/scale", inputs: { scale: 18.200000762939453 } },
+    { id: "npr_emit", type: "vector_math/scale", inputs: { scale: 14.56 } },
     { id: "principled_base", type: "hue_sat", inputs: { hue: 0.5, saturation: 1.0, value: 0.800000011920929, fac: 1.0 } },
     {
       id: "principled",

package/src/graph/presets/face.ts

@@ -29,7 +29,7 @@ export const FACE_GRAPH: ShaderGraph = {
     { id: "lit_tint", type: "hue_sat", inputs: { hue: 0.46000000834465027, saturation: 1.600000023841858, value: 1.5, fac: 1.0 } },
     { id: "toon_color", type: "mix/blend" },
     { id: "bc", type: "bright_contrast", inputs: { bright: 0.1, contrast: 0.2 } },
-    { id: "emission3", type: "vector_math/scale", inputs: { scale: 2.5 } },
+    { id: "emission3", type: "vector_math/scale", inputs: { scale: 2.0 } },
 
     // ── warm rim (toon*0.5+0.5 → cardinal ramp) ──
     { id: "warm_mul", type: "math/multiply", inputs: { b: 0.5 } },

package/src/graph/presets/metal.ts

@@ -27,7 +27,7 @@ export const METAL_GRAPH: ShaderGraph = {
     { id: "mix_004", type: "mix/blend" },
     { id: "hue_004", type: "hue_sat", inputs: { hue: 0.5, saturation: 1.0, value: 2.0, fac: 1.0 } },
     { id: "npr_overlay", type: "mix/overlay", inputs: { fac: 1.0 } },
-    { id: "npr_emit", type: "vector_math/scale", inputs: { scale: 8.100000381469727 } },
+    { id: "npr_emit", type: "vector_math/scale", inputs: { scale: 6.48 } },
     { id: "voro_cross", type: "vect_cross", inputs: { b: [0, 1, 0] } },
     { id: "voro", type: "tex_voronoi/color", inputs: { scale: 4.3 } },
     { id: "voro_ramp", type: "ramp_linear", inputs: { pos0: 0.0, pos1: 1.0 } },

package/src/graph/registry.ts

@@ -123,7 +123,11 @@ const uberNode = (slot: number): NodeSpec => ({
     roughness: F(0.6),
     occlusion: F(1),
     normal: { type: "vector", contextDefault: "n" },
-    direction: { type: "vector", requiresLink: true },
+    // The key light: this draw's, by default — the sun, or the light on the
+    // character's own layer — its way and its colour (the game's _LocalLightDir,
+    // _LocalLightColor). Linked, a look supplies its own (ag_key_light).
+    direction: { type: "vector", contextDefault: "l" },
+    light_color: { type: "color", contextDefault: "sun" },
     // Unity's v into the ramp: the property map's alpha, which picks a
     // surface's band (skin 0.702, hair and pale cloth 0.506).
     row: F(0.702),
@@ -137,24 +141,45 @@ const uberNode = (slot: number): NodeSpec => ({
     rim_in_light: F(1),
     emission: C([0, 0, 0]),
     reflection: F(1),
+    // THE STUDIO AMBIENT (_GlobalIlluminationOverride): the game blends a
+    // character's ambient from its own reflection cube's smallest mip — near
+    // neutral, 0.4–0.9 across the newer skins — over the scene's light, by the
+    // material's blend (bodies 0.8, hair 1, faces 0.5). It is what keeps a
+    // character clean on a coloured stage.
+    studio: C([0.6, 0.6, 0.6]),
+    studio_blend: F(0),
     // A face's SDF shade (ag_face_sdf); left at -1, the material reads N·L.
     shade: F(-1),
     // 1: the game's FACE_MODE — no GGX, the environment at a flat 0.0157.
     face: F(0),
+    // A face's SDF highlight (ag_face_spec), in place of GGX.
+    face_spec: F(0),
+    // 1: hair (_ANISOTROPIC_SPECULAR) — its ring (ag_hair_ring) in place of GGX,
+    // the environment at a flat 0.0157.
+    hair: F(0),
+    hair_spec: C([0, 0, 0]),
   },
   outputs: { color: "color" },
   emit: (a) =>
-    `ag_uber(${slot}u, ${a.base}, ${a.metallic}, ${a.roughness}, ${a.occlusion}, ${a.normal}, ${a.direction}, ${a.row}, ${a.receive_shadow}, ` +
-    `${a.rim_mask}, ${a.rim_mid}, ${a.rim_width}, ${a.rim_tint}, ${a.rim_intensity}, ${a.rim_albedo}, ${a.rim_in_light}, ${a.emission}, ${a.reflection}, ${a.shade}, ${a.face}, input.worldPos, v)`,
+    `ag_uber(${slot}u, ${a.base}, ${a.metallic}, ${a.roughness}, ${a.occlusion}, ${a.normal}, ${a.direction}, ${a.light_color}, ${a.row}, ${a.receive_shadow}, ` +
+    `${a.rim_mask}, ${a.rim_mid}, ${a.rim_width}, ${a.rim_tint}, ${a.rim_intensity}, ${a.rim_albedo}, ${a.rim_in_light}, ${a.emission}, ${a.reflection}, ${a.studio}, ${a.studio_blend}, ${a.shade}, ${a.face}, ${a.face_spec}, ${a.hair}, ${a.hair_spec}, input.worldPos, v)`,
   takesLight: true,
 })
 const UBER_NODES: Record<string, NodeSpec> = Object.fromEntries([0, 1, 2, 3].map((s) => [`ag_uber/${s}`, uberNode(s)]))
-// The face's SDF shade, the image on the slot the type names — 104903's face
-// template (SDF_04_shaonv) by default in the AG pack.
+// How much a colour reads as skin (ag_skin): what picks a surface's ramp row in
+// a general look, where the game would read its property mask.
+const AG_SKIN: NodeSpec = {
+  inputs: { color: C([1, 1, 1], true) },
+  outputs: { value: "float" },
+  emit: (a) => `ag_skin(${a.color})`,
+}
+// The face's SDF shade, the image on the slot the type names. An empty slot
+// reads white: the whole face takes one shade from where the key light stands
+// to the head, the game's flat face for a model without its SDF.
 const faceSdfNode = (slot: number): NodeSpec => ({
   inputs: {
     uv: { type: "vector", contextDefault: "vec3f(input.uv, 0.0)" },
-    direction: { type: "vector", requiresLink: true },
+    direction: { type: "vector", contextDefault: "l" },
     normal: { type: "vector", contextDefault: "n" },
     smoothness: F(0.1),
     invert: F(0),
@@ -163,6 +188,55 @@ const faceSdfNode = (slot: number): NodeSpec => ({
   emit: (a) => `ag_face_sdf(${slot}u, ${a.uv}.xy, ${a.direction}, ${a.normal}, ${a.smoothness}, ${a.invert})`,
 })
 const FACE_SDF_NODES: Record<string, NodeSpec> = Object.fromEntries([0, 1, 2, 3].map((s) => [`ag_face_sdf/${s}`, faceSdfNode(s)]))
+// The newer SDF (_SDFType 1): a painted face normal, not a threshold field.
+const faceSdfNewNode = (slot: number): NodeSpec => ({
+  ...faceSdfNode(slot),
+  emit: (a) => `ag_face_sdf_new(${slot}u, ${a.uv}.xy, ${a.direction}, ${a.normal}, ${a.smoothness}, ${a.invert})`,
+})
+const FACE_SDF_NEW_NODES: Record<string, NodeSpec> = Object.fromEntries([0, 1, 2, 3].map((s) => [`ag_face_sdf_new/${s}`, faceSdfNewNode(s)]))
+// The face's highlight from the newer SDF's green and blue.
+const faceSpecNode = (slot: number): NodeSpec => ({
+  inputs: {
+    uv: { type: "vector", contextDefault: "vec3f(input.uv, 0.0)" },
+    direction: { type: "vector", contextDefault: "l" },
+    normal: { type: "vector", contextDefault: "n" },
+    anisotropy: F(1),
+    shift: F(0),
+  },
+  outputs: { value: "float" },
+  emit: (a) => `ag_face_spec(${slot}u, ${a.uv}.xy, ${a.direction}, ${a.normal}, v, ${a.anisotropy}, ${a.shift})`,
+})
+// The hair's angel ring, the band on the slot's image.
+const hairRingNode = (slot: number): NodeSpec => ({
+  inputs: {
+    uv: { type: "vector", contextDefault: "vec3f(input.uv, 0.0)" },
+    normal: { type: "vector", contextDefault: "n" },
+    color: C([1, 1, 1]),
+    anisotropy: F(1),
+    shift: F(0),
+  },
+  outputs: { color: "color" },
+  emit: (a) => `ag_hair_ring(${slot}u, ${a.uv}.xy, ${a.normal}, v, ${a.color}, ${a.anisotropy}, ${a.shift})`,
+})
+const HAIR_RING_NODES: Record<string, NodeSpec> = Object.fromEntries([0, 1, 2, 3].map((s) => [`ag_hair_ring/${s}`, hairRingNode(s)]))
+// The game's pupil (SimPipeline/Character/Eye): unlit relief, matcap and
+// glints — slots: 0 depth, 1 normal, 2 matcap, 3 glint mask.
+const AG_EYE: NodeSpec = {
+  inputs: {
+    height_scale: F(0.2), min_layer: F(8), max_layer: F(32), intensity: F(0.9),
+    main_color: C([1, 1, 1]), matcap_color: C([1, 1, 1]), matcap_pow: F(1),
+    mask_scale: F(0.15), mask_soft: F(0.014),
+    mask2: F(0), mask2_color: C([1, 1, 1]), mask3: F(0), mask3_color: C([1, 1, 1]),
+    blink: F(0), blink_scale: F(10), scale_speed: F(0.1), rotate_speed: F(0.6), blink_angle: F(5),
+    level: F(1),
+  },
+  outputs: { color: "color" },
+  emit: (a) =>
+    `ag_eye(input.uv, n, v, input.worldPos, ${a.height_scale}, ${a.min_layer}, ${a.max_layer}, ${a.intensity}, ${a.main_color}, ` +
+    `${a.matcap_color}, ${a.matcap_pow}, ${a.mask_scale}, ${a.mask_soft}, ${a.mask2}, ${a.mask2_color}, ${a.mask3}, ${a.mask3_color}, ` +
+    `${a.blink}, ${a.blink_scale}, ${a.scale_speed}, ${a.rotate_speed}, ${a.blink_angle}, ${a.level})`,
+}
+const FACE_SPEC_NODES: Record<string, NodeSpec> = Object.fromEntries([0, 1, 2, 3].map((s) => [`ag_face_spec/${s}`, faceSpecNode(s)]))
 
 // A packed property map on the slot the type names — the game's material
 // contract: R metal, G perceptual roughness (answered as smoothness, Unity's
@@ -630,7 +704,12 @@ export const NODE_REGISTRY: Record<string, NodeSpec> = {
   // Principled is one: the ramp image on the group slot named by the type.
   // Defaults are 104903's skin.
   ...UBER_NODES,
+  ag_skin: AG_SKIN,
   ...FACE_SDF_NODES,
+  ...FACE_SDF_NEW_NODES,
+  ...FACE_SPEC_NODES,
+  ag_eye: AG_EYE,
+  ...HAIR_RING_NODES,
   ...PROPERTY_MAP_NODES,
 
   /**

package/src/graph/schema.ts

@@ -75,6 +75,20 @@ export type ShaderGraph = {
    * images keeps those.
    */
   images?: ({ url: string; srgb?: boolean } | null)[]
+  /**
+   * The look's outline, the anime game's in place of MMD's flat edge: the
+   * material's picture × colour, toward shadowColor where the key light leaves
+   * it, `width` world units wide (held 1.2–3 px of a 1920-wide frame) — an Aether
+   * Gazer _OutlineWidth w is w·1.3/1920·8 here. Unset, the PMX edge stands.
+   */
+  outline?: {
+    color: [number, number, number]
+    shadowColor: [number, number, number]
+    width: number
+    /** One of `images` (its index) whose colour multiplies the outline at the
+     *  mesh's uvs — the game's per-texel outline mask. */
+    tint?: number
+  }
 }
 
 export type Diagnostic = {