reze-engine 0.66.4 → 0.67.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 = {

package/src/shaders/materials/nodes.ts

@@ -471,9 +471,10 @@ fn _ag_ramp(slot: u32, uv: vec2f) -> vec4f {
  * Lamps and fog are the engine's, laid on after.
  */
 fn ag_uber(slot: u32, base: vec3f, metallic: f32, roughness: f32, occlusion: f32, n: vec3f, l: vec3f,
-           row: f32, receive: f32, rimMask: f32, rimMid: f32, rimWidth: f32, rimTint: vec3f,
+           lightColor: vec3f, row: f32, receive: f32, rimMask: f32, rimMid: f32, rimWidth: f32, rimTint: vec3f,
            rimIntensity: f32, rimAlbedo: f32, rimInLight: f32, emissive: vec3f, reflection: f32,
-           shade: f32, face: f32, wp: vec3f, v: vec3f) -> vec3f {
+           studio: vec3f, studioBlend: f32, shade: f32, face: f32, faceSpec: f32, hair: f32, hairSpec: vec3f,
+           wp: vec3f, v: vec3f) -> vec3f {
   let diffuse = base * (1.0 - metallic);
   let f0 = mix(vec3f(0.04), base, metallic);
   let pr = clamp(roughness, 0.0, 1.0);
@@ -510,9 +511,15 @@ fn ag_uber(slot: u32, base: vec3f, metallic: f32, roughness: f32, occlusion: f32
   let rim = tint * edge * (1.0 + rimInLight * (u - 1.0));
 
   // A face (FACE_MODE) takes no GGX: its light is the ramp, the rim and its
-  // optional SDF highlight (off unless _FaceSpecular).
+  // SDF highlight (ag_face_spec), grey, × (0.9u + 0.1).
   let isFace = face > 0.5;
-  let direct = (select(spec * f0, vec3f(0.0), isFace) + rim) * u + diffuse * ramp;
+  // Hair (_ANISOTROPIC_SPECULAR) takes its angel ring (ag_hair_ring) in place of
+  // GGX, not × F0: × (0.29u + 0.1/π).
+  let isHair = hair > 0.5;
+  var hl = select(spec * f0, hairSpec * (0.29 * u + 0.03183099), isHair);
+  hl = select(hl, vec3f(faceSpec * (0.9 * u + 0.1)), isFace);
+  // under the key light's colour, as the pass ends its direct term (× _LocalLightColor)
+  let direct = ((hl + rim) * u + diffuse * ramp) * lightColor;
 
   // the environment, with the game's fit of the split-sum
   let a004 = min((1.0 - pr) * (1.0 - pr), exp2(-9.28 * ndv)) * (1.0 - pr) + (0.0425 - 0.0275 * pr);
@@ -522,11 +529,33 @@ fn ag_uber(slot: u32, base: vec3f, metallic: f32, roughness: f32, occlusion: f32
   let env = rzWorldSpecularLod(reflect(-v, n), pr, 1.0) * reflection;
 
   // ... and the environment at a flat 0.0157 rather than through the BRDF fit.
-  let envTerm = select((f0 * A + B) * env, env * 0.0157, isFace);
-  return emissive + rzObjectAmbient(n) * diffuse + envTerm + direct;
+  let envTerm = select((f0 * A + B) * env, env * 0.0157, isFace || isHair);
+  // the ambient: the scene's, blended toward the studio's by the material
+  let ambient = mix(rzObjectAmbient(n), studio, saturate(studioBlend));
+  return emissive + ambient * diffuse + envTerm + direct;
 }
 
 
+/**
+ * How much an albedo reads as skin, 0..1 — for a general look that has no
+ * game property mask to pick a surface's ramp row with. Skin across the game's
+ * newer characters (and the PMX textures ripped from them) is warm — red over
+ * green over blue, a hue within about 0..45 degrees — moderately saturated and
+ * fairly light; cloth, hair, metal and eyes are rarely all three.
+ */
+fn ag_skin(c: vec3f) -> f32 {
+  let s = clamp(c, vec3f(0.0), vec3f(1.0));
+  let mx = max(s.r, max(s.g, s.b));
+  let mn = min(s.r, min(s.g, s.b));
+  let sat = (mx - mn) / max(mx, 1e-4);
+  // hue in degrees for the red-to-yellow sextant, where skin lives
+  let hue = select(-1.0, 60.0 * (s.g - s.b) / max(mx - mn, 1e-4), s.r >= s.g && s.g >= s.b && mx - mn > 1e-4);
+  let warm = smoothstep(-2.0, 4.0, hue) * (1.0 - smoothstep(38.0, 52.0, hue));
+  let tinted = smoothstep(0.06, 0.14, sat) * (1.0 - smoothstep(0.55, 0.75, sat));
+  let light = smoothstep(0.35, 0.55, mx);
+  return warm * tinted * light;
+}
+
 /**
  * The face's shade from its SDF image (Uber FACE_MODE, _SDFType 0), in place of
  * N·L: the key light taken into the face's frame and flattened, the field read
@@ -560,11 +589,151 @@ fn ag_face_sdf(slot: u32, uv: vec2f, l: vec3f, n: vec3f, smoothness: f32, invert
   var m2 = max(saturate((b - th - 1.0) / k + 0.5), saturate((a - w) / k + 0.5));
   m2 = min(m2, min(saturate((a + w) / k + 0.5), saturate((b + w) / k + 0.5)));
   var r = flag * (m1 - m2) + m2;
-  r *= (1.0 - abs(lf.z)) * 0.5 + 0.5;
+  r *= (1.0 - abs(lf.y)) * 0.5 + 0.5;
   r *= saturate(dot(n, l)) * 0.5 + 0.5;
   return r;
 }
 
+/** The game's face frame (_World2Face) from the head bone: x to the face's
+ *  right, y up, z out of it — a vector in world space taken into it. */
+fn _ag_face_frame(d: vec3f) -> vec3f {
+  let hb = skinMats[u32(max(material.headBoneIndex, 0.0))];
+  return vec3f(dot(d, -normalize(hb[0].xyz)), dot(d, normalize(hb[1].xyz)), dot(d, -normalize(hb[2].xyz)));
+}
+
+/**
+ * The face's shade from its newer SDF image (Uber FACE_MODE, _SDFType 1), in
+ * place of N·L. The image paints, per texel, a normal in the face's level
+ * plane (alpha: its angle off the face's forward, toward the side the light
+ * is on) and how far it replaces the surface's own (red); three taps soften
+ * it. The painted normal yields to the real one as the light climbs, and the
+ * shade is a linear step of it against the light, _BlendSmoothness wide.
+ */
+fn ag_face_sdf_new(slot: u32, uv: vec2f, l: vec3f, n: vec3f, smoothness: f32, invert: f32) -> f32 {
+  let lf = normalize(_ag_face_frame(l));
+  let nf = normalize(_ag_face_frame(n));
+  let flip = lf.x > 0.0;
+  // Unity's v runs up: uv is the mesh's (PMX, v down)
+  let ub = vec2f(mix(uv.x, 1.0 - uv.x, invert), 1.0 - uv.y);
+  let x0 = select(ub.x, 1.0 - ub.x, flip);
+  let x1 = select(ub.x - 0.004, 1.0 - (ub.x - 0.004), flip);
+  let x2 = select(ub.x + 0.004, 1.0 - (ub.x + 0.004), flip);
+  let t0 = _ag_ramp(slot, vec2f(x0, ub.y));
+  let t1 = _ag_ramp(slot, vec2f(x1, ub.y - 0.004));
+  let t2 = _ag_ramp(slot, vec2f(x2, ub.y - 0.004));
+  let w = (t0.r + t1.r + t2.r) / 3.0;
+  let th = ((t0.a + t1.a + t2.a) / 3.0 * 2.0 - 1.0) * 1.5707964;
+  let side = select(vec3f(-1.0, 0.0, 0.0), vec3f(1.0, 0.0, 0.0), flip);
+  var ns = side * sin(th) + vec3f(0.0, 0.0, 1.0) * cos(th);
+  ns = normalize(mix(ns, nf, lf.y * lf.y));
+  ns = normalize(mix(nf, ns, w));
+  let sm = max(smoothness, 0.001);
+  let lo = -sm * w;
+  let hi = w * (sm - 1.0) + 1.0;
+  return (clamp(dot(ns, lf), lo, hi) - lo) / (hi - lo);
+}
+
+/**
+ * The face's highlight (Uber FACE_MODE with the newer SDF), its GGX: the
+ * SDF image's green and blue paint a nose and cheek glint per light angle, lit
+ * where both pass a threshold set by how far the light, swung 85% toward the
+ * camera, comes from the front; the painted band slides up with the view
+ * (_AnisotropyShift). × _Anisotropy/π, the light's frontality and N·V. The
+ * pass lays it on as u·(0.9u + 0.1)·this — ag_uber's face_spec.
+ */
+fn ag_face_spec(slot: u32, uv: vec2f, l: vec3f, n: vec3f, v: vec3f, anisotropy: f32, shift: f32) -> f32 {
+  let lf = _ag_face_frame(l);
+  let lxz = lf.xz * inverseSqrt(max(dot(lf.xz, lf.xz), 1.1754944e-38));
+  // unity_CameraToWorld column 2: OpenGL-style, the camera's BACK, toward the viewer
+  let cf = _ag_face_frame(vector_camera_to_world(vec3f(0.0, 0.0, 1.0))).xz;
+  let hd = normalize(mix(lxz, cf, 0.85));
+  let ub = vec2f(uv.x, 1.0 - uv.y);
+  let s = _ag_ramp(slot, vec2f(select(ub.x, 1.0 - ub.x, hd.x < 0.0), ub.y - v.y * shift));
+  let t = clamp(saturate(-hd.y - 0.70710677) * 3.4142134, 0.01, 0.99);
+  let on = select(0.0, 1.0, s.g >= 1.0 - t && s.b >= t);
+  return on * anisotropy / 3.14159265 * saturate((lxz.y * 0.5 + 0.5) * 4.0 - 3.0) * saturate(dot(n, v));
+}
+
+/**
+ * Aether Gazer's pupil (SimPipeline/Character/Eye, ForwardBase): unlit. The
+ * iris is a parallax-occlusion relief on the depth image (slot 0, red = height
+ * up from 1 − depth), marched in the eye's own tangent frame toward the eye of
+ * the viewer, _MinLayer..._MaxLayer layers as the view grazes; the material's
+ * picture is read where the march stops, brightened by its depth × _Intensity.
+ * A matcap (slot 2) on the normal map (slot 1, tangent normal as 0..1) scales
+ * it by (1 + matcap), and the sparkle mask (slot 3, blue / green) adds its
+ * glints, pulsing and wobbling with the clock. × level (_ProbeLightingBase).
+ */
+fn ag_eye(uv: vec2f, n: vec3f, v: vec3f, wp: vec3f, heightScale: f32, minLayer: f32, maxLayer: f32,
+          intensity: f32, mainColor: vec3f, matColor: vec3f, matPow: f32, maskScale: f32, maskSoft: f32,
+          mask2: f32, mask2Color: vec3f, mask3: f32, mask3Color: vec3f, blink: f32, blinkScale: f32,
+          scaleSpeed: f32, rotateSpeed: f32, blinkAngle: f32, level: f32) -> vec3f {
+  // the tangent frame of the mesh uvs, as the march walks them
+  let dp1 = dpdx(wp);
+  let dp2 = dpdy(wp);
+  let du1 = dpdx(uv);
+  let du2 = dpdy(uv);
+  let det = du1.x * du2.y - du2.x * du1.y;
+  let inv = select(0.0, 1.0 / det, abs(det) > 1e-12);
+  let tu = (dp1 * du2.y - dp2 * du1.y) * inv;
+  let tv = (dp2 * du1.x - dp1 * du2.x) * inv;
+  let vt = vec3f(dot(v, safe_normal(tu)), dot(v, safe_normal(tv)), dot(v, n));
+  let vz = max(abs(vt.z), 1e-3);
+  let layers = mix(ceil(maxLayer), ceil(minLayer), saturate(abs(vt.z)));
+  // against the view, both ways in these uvs: measured, the iris error 48 -> 10 of 255
+  let stp = vec3f(-vt.xy * heightScale, vz) / (layers * vz);
+  var p = vec3f(uv, 0.0) + stp;
+  var prev = vec3f(uv, 0.0);
+  var depth = 1.0 - textureSampleLevel(groupTexture0, diffuseSampler, p.xy, 0.0).r;
+  var prevDepth = 0.0;
+  for (var i = 0; i < 16; i++) {
+    if (p.z >= depth) { break; }
+    prev = p;
+    prevDepth = depth;
+    p += stp;
+    depth = 1.0 - textureSampleLevel(groupTexture0, diffuseSampler, p.xy, 0.0).r;
+  }
+  // between the last two layers, where the ray crossed the relief
+  let after = depth - p.z;
+  let before = prevDepth - prev.z;
+  let w = select(0.0, after / (after - before), abs(after - before) > 1e-6);
+  let uvP = mix(p.xy, prev.xy, w);
+  let dLast = depth;
+  var alb = textureSampleLevel(diffuseTexture, diffuseSampler, uvP, 0.0).rgb * mainColor;
+  alb += alb * dLast * intensity;
+  // the matcap, multiplied in
+  let nm = node_normal_map(textureSampleLevel(groupTexture1, diffuseSampler, uv, 0.0).rgb, 1.0, n, wp, uv);
+  let vn = (camera.view * vec4f(nm, 0.0)).xy;
+  let mc = textureSampleLevel(groupTexture2, diffuseSampler, vn * 0.5 + 0.5, 0.0).rgb * matColor * matPow;
+  var col = alb + alb * mc;
+  // the glints: the mask wobbled about the eye's centre, pulsing
+  let t = camera.time;
+  let a = sin(radians(cos(t * rotateSpeed) * blinkAngle));
+  let c = cos(a);
+  let d = uv - vec2f(0.5);
+  let uvR = select(uv, vec2f(c * d.x - a * d.y, a * d.x + c * d.y) + 0.5, blink > 0.5);
+  let m = textureSampleLevel(groupTexture3, diffuseSampler, uvR, 0.0);
+  let lo = saturate(maskScale - maskSoft);
+  let hi = saturate(maskScale + maskSoft);
+  let s1 = select(0.0, smoothstep(lo, hi, m.g), mask2 > 0.5);
+  let s2 = select(0.0, smoothstep(lo, hi, m.b), mask3 > 0.5);
+  let k = select(1.0, (sin(12.0 * t * scaleSpeed) * 0.5 + 0.7) * blinkScale, blink > 0.5);
+  col += saturate(k * s1 * mask2Color + k * s2 * mask3Color);
+  return col * level;
+}
+
+/**
+ * Aether Gazer's hair highlight, its angel ring (Uber _ANISOTROPIC_SPECULAR,
+ * _HairLightingMode 0): a band painted in the hair's uvs (the slot's image),
+ * sliding up the strands as the view climbs (_AnisotropyShift), × the ring's
+ * colour and N·V·_Anisotropy. ag_uber's hair_spec; it lays on the u factor.
+ */
+fn ag_hair_ring(slot: u32, uv: vec2f, n: vec3f, v: vec3f, color: vec3f, anisotropy: f32, shift: f32) -> vec3f {
+  let ub = vec2f(uv.x, 1.0 - uv.y);
+  let b = _ag_ramp(slot, vec2f(ub.x, ub.y - v.y * shift)).rgb;
+  return b * color * (saturate(dot(n, v)) * anisotropy);
+}
+
 fn group_tex0(uv: vec2f) -> vec4f { return textureSample(groupTexture0, diffuseSampler, uv); }
 fn group_tex1(uv: vec2f) -> vec4f { return textureSample(groupTexture1, diffuseSampler, uv); }
 fn group_tex2(uv: vec2f) -> vec4f { return textureSample(groupTexture2, diffuseSampler, uv); }

package/src/shaders/passes/composite.ts

@@ -131,7 +131,7 @@ override APPLY_GAMMA: bool = true;
 @group(0) @binding(0) var hdrTex: texture_2d<f32>;
 @group(0) @binding(1) var bloomTex: texture_2d<f32>;   // bloomUpTexture mip 0 (full pyramid top)
 @group(0) @binding(2) var bloomSamp: sampler;
-@group(0) @binding(3) var<uniform> viewU: array<vec4<f32>, 15>;
+@group(0) @binding(3) var<uniform> viewU: array<vec4<f32>, 16>;
 // Aux mask/alpha texture. .r = bloom mask (unused here; bloom blit uses it).
 // .g = accumulated canvas alpha (what hdr.a carried before the HDR format
 // became rg11b10ufloat). We unpremultiply HDR by this alpha for tonemap, then
@@ -153,6 +153,8 @@ override APPLY_GAMMA: bool = true;
 // viewU[9] = (grade slope.rgb, grade flags) — bit 0 the CDL grade(), bit 1 the
 //            scene's own LUT (setStageGrade) — see _rzGradeScene() below.
 // viewU[10] = (camera world position, _) — refreshed with the basis above.
+// viewU[11..14] = the cast's positions (effects; count in viewU[10].w).
+// viewU[15] = (soft curve contrast, _, _, _).
 // invGamma = 1/gamma precomputed on CPU — avoids a per-pixel divide.
 @group(0) @binding(6) var bgEquirect: texture_2d<f32>;
 // The scene pass's own MSAA depth buffer, bound depth-only. NOT an extra
@@ -251,7 +253,7 @@ fn srgb_encode(x: f32) -> f32 {
  * The game's ACES branch is off in every scene measured.
  */
 fn softTransform(c: vec3f) -> vec3f {
-  let t = pow(max(vec3f(1.0) - exp(-2.5 * max(c, vec3f(0.0))), vec3f(0.0)), vec3f(1.4));
+  let t = pow(max(vec3f(1.0) - exp(-2.5 * max(c, vec3f(0.0))), vec3f(0.0)), vec3f(viewU[15].x));
   return vec3f(srgb_encode(t.r), srgb_encode(t.g), srgb_encode(t.b));
 }
 

package/src/shaders/passes/outline.ts

@@ -27,6 +27,19 @@ import { DISSOLVE_WGSL } from "../materials/common"
  * edgeSize 16..20, so this is 20.
  */
 export const RZ_OUTLINE_DISSOLVE_OFFSET = 20
+/** Where the scene-wide width multiplier sits, in bytes — the float after
+ *  dissolve (Engine.setOutlineWidth). */
+export const RZ_OUTLINE_WIDTH_OFFSET = 24
+/** Where the scene-wide colour override sits, in bytes: rgb and a weight, 0
+ *  for the material's own edge colour (Engine.setOutlineColor). */
+export const RZ_OUTLINE_COLOR_OFFSET = 32
+/** Where a style graph's outline (ShaderGraph.outline) sits, in bytes: the
+ *  textured flag at 28, then its shadow colour at 48. Unset, a hull draws its
+ *  PMX edge colour flat, as MMD does. */
+export const RZ_OUTLINE_TEXTURED_OFFSET = 28
+export const RZ_OUTLINE_SHADOW_OFFSET = 48
+/** The hull's own block, in floats. */
+export const RZ_OUTLINE_UNIFORM_FLOATS = 16
 
 export function outlineShaderWgsl(): string {
   return /* wgsl */ `
@@ -40,7 +53,7 @@ struct CameraUniforms {
   viewportHeight: f32,
 };
 
-// THE HULL'S OWN BLOCK, not the material's. 32 bytes of edge data, which is all
+// THE HULL'S OWN BLOCK, not the material's. 48 bytes of edge data, which is all
 // this pass shades with — and dissolve, which it has to obey.
 //
 // It reached for the material block's own layout first, declaring the skipped
@@ -53,15 +66,34 @@ struct MaterialUniforms {
   edgeColor: vec4f,
   edgeSize: f32,
   dissolve: f32,
-  _padding2: f32,
-  _padding3: f32,
+  /** The scene's width multiplier (setOutlineWidth), the same on every hull:
+   *  scales the author's edgeSize rather than replacing it, so a model's thin
+   *  and thick lines keep their proportion. */
+  widthScale: f32,
+  /** 1: a style graph's outline, the game's (Uber pass "Outline"): edgeSize is
+   *  a world width, held between 1.2 and 3 px of a 1920-wide frame, and the
+   *  colour is the picture × lerp(shadowColor, edgeColor, the key's
+   *  half-Lambert). 0: the PMX edge, flat. */
+  textured: f32,
+  /** The scene's colour in place of edgeColor.rgb, by .a (0 or 1). The
+   *  material's own alpha still holds — a line its author made sheer stays so. */
+  colorOverride: vec4f,
+  shadowColor: vec4f,
 };
 
+struct OutlineLight { direction: vec4f, color: vec4f, };
+/** The head of the scene's light block: the key is lights[0]. */
+struct OutlineLights { ambientColor: vec4f, lights: array<OutlineLight, 4>, };
+
 @group(0) @binding(0) var<uniform> camera: CameraUniforms;
 @group(0) @binding(1) var edgeSampler: sampler;
+@group(0) @binding(2) var<uniform> light: OutlineLights;
 @group(1) @binding(0) var<storage, read> skinMats: array<mat4x4f>;
 @group(2) @binding(0) var<uniform> material: MaterialUniforms;
 @group(2) @binding(1) var diffuseTexture: texture_2d<f32>;
+/** A look's outline tint (ShaderGraph.outline.tint): one of its images, white
+ *  when it names none. */
+@group(2) @binding(2) var tintTexture: texture_2d<f32>;
 
 struct VertexOutput {
   @builtin(position) position: vec4f,
@@ -76,6 +108,7 @@ struct VertexOutput {
   /** How much of a pixel-wide line this one really is (1 = all of it): a line
    *  held at the minimum width fades by what it was short. */
   @location(3) coverage: f32,
+  @location(4) normal: vec3f,
 };
 
 /**
@@ -98,6 +131,11 @@ const RZ_OUTLINE_FULL_FIGURE = 12.5;
  *  the shortfall, so far lines thin out without aliasing into dashes. */
 const RZ_OUTLINE_MIN_PX = 1.5;
 
+fn safe_normal2(v: vec2f) -> vec2f {
+  let l = length(v);
+  return select(vec2f(0.0), v / l, l > 1e-6);
+}
+
 @vertex fn vs(
   @location(0) position: vec3f,
   @location(1) normal: vec3f,
@@ -157,21 +195,40 @@ const RZ_OUTLINE_MIN_PX = 1.5;
   // once the frame is taller than a figure. The PMX per-vertex edge scale
   // multiplies it all, as vertex colour alpha does in the game.
   let w = max(clipPos.w, 1e-4);
-  let breakDepth = RZ_OUTLINE_FULL_FIGURE * camera.projection[1][1];
-  let nearNdc = viewNormal.xy * (material.edgeSize * outlineNormal.w * 4.0 / refViewport);
-  var ndc = nearNdc * (min(w, breakDepth) / w);
-
-  // Antialiased minimum (the game's _OutlineAntialias): held at the minimum
-  // width and faded by the shortfall, never thinner. The game fades by
-  // sqrt(coverage.x · coverage.y), per axis; for one width that is the ratio
-  // itself.
-  let px = length(ndc * deviceViewport * 0.5);
-  let minPx = RZ_OUTLINE_MIN_PX * max(1.0, camera.viewportHeight / 1080.0);
+  var ndc: vec2f;
   var coverage = 1.0;
-  if (px < minPx) {
-    coverage = px / minPx;
-    ndc = select(vec2f(0.0), ndc * (minPx / px), px > 1e-6);
+  if (material.textured > 0.5) {
+    // The game's: a view-space offset of edgeSize world units along the view
+    // normal, projected, then each axis held between 1.2 px and 1.2 px ×
+    // (1 + _OutlineMaxOffsetMultiplier, 1.5) of a 1920-wide frame; a line the
+    // minimum had to push fades by how far it was pushed.
+    let off = viewNormal.xy * material.edgeSize * material.widthScale * outlineNormal.w;
+    let d1 = vec2f(off.x * camera.projection[0][0], off.y * camera.projection[1][1]) / w;
+    // the minimum along the push direction (the game's dir · 2/screen · 1.2)
+    let pxNdc = 2.0 / refViewport * 1.2 * safe_normal2(viewNormal.xy);
+    let mx = abs(pxNdc) * 2.5;
+    let o = min(mx, max(abs(d1), abs(pxNdc)));
+    // fadeOut = min(length(saturate(off − |d1|))·75, 1), on clip offsets (× w)
+    // in game units: w here is MMD units, 8 to the game's metre
+    coverage = 1.0 - min(length(saturate((o - abs(d1)) * w / 8.0)) * 75.0, 1.0);
+    ndc = o * select(vec2f(1.0), sign(d1), abs(d1) > vec2f(0.0));
+  } else {
+    let breakDepth = RZ_OUTLINE_FULL_FIGURE * camera.projection[1][1];
+    let nearNdc = viewNormal.xy * (material.edgeSize * material.widthScale * outlineNormal.w * 4.0 / refViewport);
+    ndc = nearNdc * (min(w, breakDepth) / w);
+
+    // Antialiased minimum (the game's _OutlineAntialias): held at the minimum
+    // width and faded by the shortfall, never thinner. The game fades by
+    // sqrt(coverage.x · coverage.y), per axis; for one width that is the ratio
+    // itself.
+    let px = length(ndc * deviceViewport * 0.5);
+    let minPx = RZ_OUTLINE_MIN_PX * max(1.0, camera.viewportHeight / 1080.0);
+    if (px < minPx) {
+      coverage = px / minPx;
+      ndc = select(vec2f(0.0), ndc * (minPx / px), px > 1e-6);
+    }
   }
+  output.normal = worldNormal;
   output.coverage = coverage;
   output.position = vec4f(clipPos.xy + ndc * w, clipPos.z, clipPos.w);
   output.uv = uv;
@@ -203,7 +260,8 @@ ${sceneFsOutWgsl({ name: "FSOut", aux: "mask" })}
   // bind-pose position — three passes, one rule, or they disagree about which
   // pieces are still there.
   if (material.dissolve < 0.9995 && input.faceT > material.dissolve) { discard; }
-  let texA = textureSample(diffuseTexture, edgeSampler, input.uv).a;
+  let tex = textureSample(diffuseTexture, edgeSampler, input.uv);
+  let texA = tex.a;
   if (texA < 0.05) {
     discard;
   }
@@ -212,7 +270,13 @@ ${sceneFsOutWgsl({ name: "FSOut", aux: "mask" })}
   // alpha above), it is drawn right after the surface it traces so what lies
   // under a faded line is already there, and 4× MSAA would quantize a fade to
   // four steps.
-  out.color = vec4f(material.edgeColor.rgb, material.edgeColor.a * texA * input.coverage);
+  var rgb = mix(material.edgeColor.rgb, material.colorOverride.rgb, material.colorOverride.a);
+  if (material.textured > 0.5) {
+    let lit = dot(-light.lights[0].direction.xyz, normalize(input.normal)) * 0.5 + 0.5;
+    let tint = textureSample(tintTexture, edgeSampler, input.uv).rgb;
+    rgb = tex.rgb * tint * mix(material.shadowColor.rgb, rgb, lit);
+  }
+  out.color = vec4f(rgb, material.edgeColor.a * texA * input.coverage);
   out.mask = vec4f(1.0, 1.0, 0.0, out.color.a);
 ${sceneIdPadWgsl("out")}  return out;
 }