reze-engine 0.68.7 → 0.68.9

package/src/engine.ts

@@ -354,11 +354,6 @@ type GroupInstall = {
   pipelineNoDepthWrite: GPURenderPipeline
   /** hair render-class only: the stencil-matched IS_OVER_EYES=true variant. */
   overEyesPipeline?: GPURenderPipeline
-  /** eye render-class only: the same pipeline with its cull flipped, for the
-   *  mirror pass. The eye is the ONE material class that culls a face, and a
-   *  reflection flips winding, so in the mirror the ordinary pipeline keeps
-   *  exactly the faces it exists to discard. */
-  mirrorPipeline?: GPURenderPipeline
   uniformBuffer: GPUBuffer
   /** The group's own image maps, uploaded once per apply and owned here — the
    *  install destroys them when it is replaced, so a re-apply cannot leak. */
@@ -8512,6 +8507,8 @@ export class Engine {
         { binding: 0, visibility: GPUShaderStage.VERTEX, buffer: { type: "uniform" } },
         { binding: 1, visibility: GPUShaderStage.VERTEX, buffer: { type: "read-only-storage" } },
         { binding: 2, visibility: GPUShaderStage.FRAGMENT, sampler: {} },
+        // The model's ObjectLight, for its jelly eyes.
+        { binding: 3, visibility: GPUShaderStage.VERTEX, buffer: { type: "uniform" } },
       ],
     })
     const shadowShader = this.device.createShaderModule({
@@ -15180,6 +15177,20 @@ export class Engine {
       physics.setFloor(this.physicsFloor)
     }
 
+    // Its ObjectLight: the world's ambient, and the layers its kind draws on —
+    // the cast on the character layer as well as the default one. Words:
+    // layers [0..3], ambient flag [4..7], SH [8..43], fill [44..47], jelly
+    // eyes [48..71] — see materials/common.ts.
+    const objectLight = new Float32Array(96)
+    new Uint32Array(objectLight.buffer)[0] =
+      isStage || isPlane || isProp ? RENDERING_LAYER_DEFAULT : (RENDERING_LAYER_DEFAULT | RENDERING_LAYER_CHARACTER) >>> 0
+    const lightBuffer = this.device.createBuffer({
+      label: `${name}: object light`,
+      size: objectLight.byteLength,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+    })
+    this.device.queue.writeBuffer(lightBuffer, 0, objectLight)
+
     // One per cascade: the shadow VERTEX shader reads a single matrix, and
     // which one is the only thing that differs between the cascade passes.
     const shadowBindGroups = SHADOW_CASCADES.map((_, ci) =>
@@ -15190,6 +15201,7 @@ export class Engine {
           { binding: 0, resource: { buffer: this.shadowCascadeVPBuffers[ci] } },
           { binding: 1, resource: { buffer: skinMatrixBuffer } },
           { binding: 2, resource: this.materialSampler },
+          { binding: 3, resource: { buffer: lightBuffer } },
         ],
       }),
     )
@@ -15202,23 +15214,10 @@ export class Engine {
           { binding: 0, resource: { buffer: this.castShadowVPBuffer } },
           { binding: 1, resource: { buffer: skinMatrixBuffer } },
           { binding: 2, resource: this.materialSampler },
+          { binding: 3, resource: { buffer: lightBuffer } },
         ],
       }),
     )
-
-    // Its ObjectLight: the world's ambient, and the layers its kind draws on —
-    // the cast on the character layer as well as the default one. Words:
-    // layers [0..3], ambient flag [4..7], SH [8..43], fill [44..47], jelly
-    // eyes [48..71] — see materials/common.ts.
-    const objectLight = new Float32Array(96)
-    new Uint32Array(objectLight.buffer)[0] =
-      isStage || isPlane || isProp ? RENDERING_LAYER_DEFAULT : (RENDERING_LAYER_DEFAULT | RENDERING_LAYER_CHARACTER) >>> 0
-    const lightBuffer = this.device.createBuffer({
-      label: `${name}: object light`,
-      size: objectLight.byteLength,
-      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
-    })
-    this.device.queue.writeBuffer(lightBuffer, 0, objectLight)
     const mainPerInstanceBindGroup = this.perInstanceBindGroup(name, skinMatrixBuffer, lightBuffer)
 
     const pickPerInstanceBindGroup = this.device.createBindGroup({
@@ -16189,6 +16188,10 @@ export class Engine {
       // Alpha is the switch; clamp the rest so a stacked multiply cannot send a
       // colour negative and light the material from the inside.
       for (let k = 0; k < 11; k++) if (d[k] < 0) d[k] = 0
+      // Alpha also stops at 1, as in MMD. Models ship additive +1 alpha morphs
+      // (照れ on 拾星梦语) that MMD's clamp makes a no-op; let through, alpha 2
+      // blends as src*2 - dst and burns every material white.
+      if (d[3] > 1) d[3] = 1
       if (d[3] < 0.0001) inst.morphHiddenMaterials.add(target.materialName)
       let changed = false
       for (let k = 0; k < 11; k++) {
@@ -18021,10 +18024,9 @@ export class Engine {
         if (!result.ok) return
         const module = this.cachedShaderModule(result.wgsl, `style group: ${g.id} (${renderClass})`)
         await Promise.all([
-          this.createRenderClassPipeline(renderClass, module, false, true, false, blend),
-          this.createRenderClassPipeline(renderClass, module, false, false, false, blend),
-          renderClass === "hair" ? this.createRenderClassPipeline(renderClass, module, true, true, false, blend) : null,
-          renderClass === "eye" ? this.createRenderClassPipeline(renderClass, module, false, true, true, blend) : null,
+          this.createRenderClassPipeline(renderClass, module, false, true, blend),
+          this.createRenderClassPipeline(renderClass, module, false, false, blend),
+          renderClass === "hair" ? this.createRenderClassPipeline(renderClass, module, true, true, blend) : null,
         ]).catch(() => {})
       }),
     )
@@ -18401,20 +18403,17 @@ export class Engine {
     // The single-sided twins a draw of this group will ask for (sidedPipeline),
     // built with their pipelines rather than synchronously at the first draw.
     const singleSided = inst.drawCalls.some((dc) => !dc.doubleSided && group.materials.includes(dc.materialName))
-    const variant = (overEyes: boolean, depthWrite: boolean, mirrored: boolean) =>
-      this.createRenderClassPipeline(renderClass, module, overEyes, depthWrite, mirrored, blend).then(async (p) => {
-        if (singleSided && !mirrored) await this.buildSidedTwin(p, false)
+    const variant = (overEyes: boolean, depthWrite: boolean) =>
+      this.createRenderClassPipeline(renderClass, module, overEyes, depthWrite, blend).then(async (p) => {
+        if (singleSided) await this.buildSidedTwin(p, false)
         return p
       })
     const variants = Promise.all([
-      variant(false, true, false),
+      variant(false, true),
       // The depth-write-off twin: stage transparency draws with it (see
       // pipelineForDrawCall), and a future OIT path would too.
-      variant(false, false, false),
-      renderClass === "hair" ? variant(true, true, false) : undefined,
-      // Only the eye needs one: every other class culls "none", which a flipped
-      // winding leaves alone.
-      renderClass === "eye" ? variant(false, true, true) : undefined,
+      variant(false, false),
+      renderClass === "hair" ? variant(true, true) : undefined,
     ])
     // Handled below either way; this keeps a rejection off the console while
     // the diagnostics are read.
@@ -18435,9 +18434,8 @@ export class Engine {
     let pipeline: GPURenderPipeline
     let pipelineNoDepthWrite: GPURenderPipeline
     let overEyesPipeline: GPURenderPipeline | undefined
-    let mirrorPipeline: GPURenderPipeline | undefined
     try {
-      ;[pipeline, pipelineNoDepthWrite, overEyesPipeline, mirrorPipeline] = await variants
+      ;[pipeline, pipelineNoDepthWrite, overEyesPipeline] = await variants
     } catch (e) {
       diagnostics.push({ severity: "error", message: `pipeline creation failed: ${(e as Error).message}` })
       return { ok: false, diagnostics, slotMap: result.slotMap }
@@ -18467,7 +18465,6 @@ export class Engine {
       pipeline,
       pipelineNoDepthWrite,
       overEyesPipeline,
-      mirrorPipeline,
       uniformBuffer,
       images: this.uploadGroupImages(group),
       imagesByMaterial: group.imagesByMaterial
@@ -18643,29 +18640,25 @@ export class Engine {
   /**
    * Render-class pipeline state. A group's compiled graph swaps the fragment shading; the
    * render-class owns pass integration (stencil interplay, depth bias, cull). auto = plain;
-   * eye = stamp + front cull + bias; hair = stencil-test (+ the over-eyes variant).
+   * eye = stencil stamp; hair = stencil-test (+ the over-eyes variant). Cull comes from
+   * the material's double-sided flag (sidedPipeline).
    */
   private createRenderClassPipeline(
     renderClass: RenderClass,
     module: GPUShaderModule,
     overEyes: boolean,
     depthWrite = true,
-    mirrored = false,
     blend: StyleBlend = "over",
   ): Promise<GPURenderPipeline> {
     const base = {
       label: `style ${renderClass}${overEyes ? " (over eyes)" : ""}`,
       layout: this.mainPipelineLayout,
       vertex: { module, buffers: this.materialVertexBufferLayouts },
-      // The eye front-culls — the see-through-hair look is draw order plus that
-      // cull plus the stencil stamp, and it is the deployed appearance of every
-      // published scene. In the MIRROR the winding is flipped (determinant -1,
-      // reflection.ts), so the same cull keeps the back of the eyeball and
-      // discards its front. `mirrored` flips it back rather than changing what
-      // the camera sees.
-      primitive: {
-        cullMode: (renderClass === "eye" ? (mirrored ? "back" : "front") : "none") as GPUCullMode,
-      },
+      // Every class draws both sides here and takes the PMX double-sided flag
+      // from sidedPipeline, whose single-sided twin culls front (back in the
+      // mirror's flipped winding) — the eye's old fixed cull. A double-sided
+      // iris sheet keeps the faces a turn of the eye swings away.
+      primitive: { cullMode: "none" as GPUCullMode },
       multisample: { count: Engine.MULTISAMPLE_COUNT },
     }
     const plainDepth: GPUDepthStencilState = {
@@ -18956,7 +18949,6 @@ export class Engine {
     if (dc.groupId) {
       const install = inst.styleGroups.get(dc.groupId)
       if (install) {
-        if (mirrored && install.mirrorPipeline) return install.mirrorPipeline
         return stageGlass ? install.pipelineNoDepthWrite : install.pipeline
       }
     }

package/src/graph/slots.ts

@@ -102,13 +102,14 @@ function prelude(renderClass: RenderClass, alphaMode: AlphaMode, blend: StyleBle
   // camera-averted fragments change (front surfaces have dot(n,v) > 0 and are
   // untouched), unlike a front_facing test, which PMX's clockwise winding
   // inverts. Fixes inner skirt linings (裙子白1-style flipped-normal copies)
-  // shading near-black through sheer outer layers. Eye is exempt: it FRONT-culls
-  // by design, so its visible fragments are back faces with intended normals.
+  // shading near-black through sheer outer layers. Eye is exempt: its normals
+  // shade as authored.
   const flip =
     renderClass === "eye" ? "" : "\n  n = select(-n, n, dot(n, v) >= 0.0);"
   return `@fragment fn fs(input: VertexOutput) -> FSOut {
-${PLAIN_SAMPLE}  // MMD alpha semantics: material alpha × texture alpha.
-  let alpha = material.alpha * tex_s.a;
+${PLAIN_SAMPLE}  // MMD alpha semantics: material alpha × texture alpha, capped at 1 as MMD
+  // does (a PMX can author alpha above 1; blended, it burns the material white).
+  let alpha = saturate(material.alpha * tex_s.a);
 ${discard}
 
   // ── Dissolve ──

package/src/jelly-eyes.ts

@@ -90,23 +90,23 @@ const HL_SCALE_MIN = 0.85
 const HL_SCALE_MAX = 1.2
 // The roll: while a closing expression holds, the iris turns about its eye
 // bone's X axis (左目/右目, the eyeball's centre), rolling down with the lid —
-// the angle at weight 1, and simultaneous expressions add. And it comes
-// forward a little (iris radii) with the expression and with the spring, so
-// the roll does not sink it into the white. The MME rolls with the lid
-// exactly, which the lid hides; here the roll follows on a spring of the same
-// pace and decay as the blink's, so as the eye opens the iris swings up past
-// rest and wobbles back, where it can be seen.
+// the angle at weight 1, and simultaneous expressions add. It comes forward
+// only with the spring (iris radii): pushed with the expression as well, a
+// shut eye's iris came through a lid set close in front of it (白里黑子). The MME rolls with the lid
+// exactly, which the lid hides; here the roll follows on a spring twice the
+// blink's pace with its decay, so as the eye opens the iris swings up past rest
+// and wobbles back, where it can be seen. At the blink's own pace it trailed
+// the opening lid and swung a third of an iris past centre: a jump.
 const ROLL: Record<string, number> = {
   まばたき: -15, blink: -15, Blink: -15, eye_close: -15, Fcl_EYE_Close: -15, はぅ: -15, 笑い: -5,
   ウィンク: -5, ｳｨﾝｸ: -5, wink: -5, Wink: -5, ウィンク２: -15, ｳｨﾝｸ２: -15, blink_L: -15, Fcl_EYE_Close_L: -15,
   ウィンク右: -5, ｳｨﾝｸ右: -5, wink_R: -5, Wink_R: -5, ウィンク２右: -15, ｳｨﾝｸ２右: -15, blink_R: -15, Fcl_EYE_Close_R: -15,
 }
-const ROLL_HZ = SPRING_HZ
-const ROLL_ZETA = Math.LN2 / HALF_LIFE / (2 * Math.PI * SPRING_HZ)
-// How much of the spring's swing about the expression angle shows: the whole
-// of it carried the iris up most of its radius after a blink.
-const ROLL_SWING = 0.4
-const PUSH_EXPRESSION = 0.15
+const ROLL_HZ = 6
+const ROLL_ZETA = Math.LN2 / HALF_LIFE / (2 * Math.PI * ROLL_HZ)
+// How much of the spring's swing about the expression angle shows: a
+// twenty-fifth of an iris radius past centre after a blink.
+const ROLL_SWING = 0.25
 const PUSH_ELASTIC = 0.04
 // A highlight sheet by name, for rigs that keep it on its own material.
 const HIGHLIGHT = /ハイライト|ﾊｲﾗｲﾄ|高光|highlight|hilight|(^|[^a-z])hl([^a-z]|$)/i
@@ -288,10 +288,23 @@ export class JellyEyes {
     const l = index("左目")
     const r = index("右目")
     this.headBone = index("頭")
-    const names = model.getMorphing().morphs.map((m) => m.name)
-    const find = (list: string[]) => list.map((n) => names.indexOf(n)).filter((i) => i >= 0)
+    const all = model.getMorphing().morphs
+    const names = all.map((m) => m.name)
+    // The weights read are resolved, so a group whose every target is named
+    // (Reze's まばたき is ウィンク２ + ウィンク２右) arrives through its
+    // leaves; counted as well, a blink rolled the iris twice as far.
+    const known = new Set([...BOTH, ...LEFT, ...RIGHT])
+    const resolved = (i: number) => {
+      const refs = all[i].groupReferences
+      return !!refs?.length && refs.every((r) => known.has(names[r.morphIndex]))
+    }
+    const morphIndex = (n: string) => {
+      const i = names.indexOf(n)
+      return i >= 0 && !resolved(i) ? i : -1
+    }
+    const find = (list: string[]) => list.map(morphIndex).filter((i) => i >= 0)
     this.morphs = [find(BOTH), find(LEFT), find(RIGHT)]
-    const rolls = (list: string[]) => list.map((n) => ({ morph: names.indexOf(n), deg: ROLL[n] ?? 0 })).filter((r) => r.morph >= 0 && r.deg !== 0)
+    const rolls = (list: string[]) => list.map((n) => ({ morph: morphIndex(n), deg: ROLL[n] ?? 0 })).filter((r) => r.morph >= 0 && r.deg !== 0)
     this.rolls = [rolls([...BOTH, ...LEFT]), rolls([...BOTH, ...RIGHT])]
     this.rest = findIrises(model, l, r, both)
     // The bone that carries each iris, which may be under the eye bone.
@@ -423,7 +436,7 @@ export class JellyEyes {
       const pivot = rest.pivot
       o.set(pivot ? [pivot[0], pivot[1], pivot[2], (this.roll[e] + (s.roll - this.roll[e]) * ROLL_SWING) * DEG * g] : [0, 0, 0, 0], 80 + e * 4)
       const hs = (k: 0 | 1) => Math.max(HL_SCALE_MIN, Math.min(HL_SCALE_MAX, 1 + x * HL_SCALE[k] * g))
-      o.set([hs(0), hs(1), (s.closure * PUSH_EXPRESSION + Math.min(Math.abs(x), SPRING_LIMIT) * PUSH_ELASTIC) * r * g, 0], 88 + e * 4)
+      o.set([hs(0), hs(1), Math.min(Math.abs(x), SPRING_LIMIT) * PUSH_ELASTIC * r * g, 0], 88 + e * 4)
     }
   }
 
@@ -550,6 +563,11 @@ function blink(s: EyeState, dt: number): void {
  * As draw ids (1-based over the materials that draw, as the engine numbers
  * MaterialUniforms.materialId), at most two. A rig whose highlight is painted
  * into the iris has none, and only the iris moves.
+ *
+ * A layer drawn on vertices an earlier layer already uses is a copy of that
+ * layer (白里黑子's ☆ and ❤ are star and heart irises on the iris's own
+ * vertices), so it moves with it. Slid as a highlight, a copy of the dome sits
+ * in front of the iris on one half, flipping sides with the tremble.
  */
 function findHighlights(model: Model, rest: [EyeRest, EyeRest]): number[] {
   const materials = model.getMaterials?.() ?? []
@@ -557,6 +575,7 @@ function findHighlights(model: Model, rest: [EyeRest, EyeRest]): number[] {
   const iris = new Set([...rest[0].verts, ...rest[1].verts])
   if (!materials.length || !indices.length || !iris.size) return []
   const layers: { id: number; name: string; minX: number; maxX: number; minY: number; maxY: number }[] = []
+  const used = new Set<number>()
   let start = 0
   let id = 0
   for (const m of materials) {
@@ -564,16 +583,21 @@ function findHighlights(model: Model, rest: [EyeRest, EyeRest]): number[] {
     if (count === 0) continue
     id++
     let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity
+    let copy = true
+    const mine: number[] = []
     for (let k = start; k < start + count; k++) {
       const v = indices[k]
       if (!iris.has(v)) continue
+      if (!used.has(v)) copy = false
+      mine.push(v)
       minX = Math.min(minX, positions[v * 3])
       maxX = Math.max(maxX, positions[v * 3])
       minY = Math.min(minY, positions[v * 3 + 1])
       maxY = Math.max(maxY, positions[v * 3 + 1])
     }
     start += count
-    if (minX <= maxX) layers.push({ id, name: m.name, minX, maxX, minY, maxY })
+    for (const v of mine) used.add(v)
+    if (minX <= maxX && !copy) layers.push({ id, name: m.name, minX, maxX, minY, maxY })
   }
   const out: number[] = []
   layers.forEach((l, i) => {

package/src/shaders/materials/common.ts

@@ -26,6 +26,73 @@ import { WORLD_AMBIENT_WGSL } from "../lights"
 //   group(1): per-model skinning
 //   group(2): per-material (diffuse texture + material uniforms)
 
+/** The jelly eyes' vertex move (jelly-eyes.ts). Every pass that places model
+ *  vertices takes it, or a pass that skips it draws the iris where it was —
+ *  the shadow map then shades half the moved iris with its own unmoved copy.
+ *  Reads `objectLight.jelly` and `material.materialId`, which the including
+ *  module declares. */
+export const JELLY_VERTEX_WGSL = /* wgsl */ `
+fn _rzJellyTurn(q: vec2f, a: f32) -> vec2f {
+  let c = cos(a);
+  let s = sin(a);
+  return vec2f(c * q.x - s * q.y, s * q.x + c * q.y);
+}
+
+/**
+ * Where the jelly puts an iris vertex. The iris is the part of the eye the eye
+ * bones carry, so it is moved as a whole, in bind space before skinning:
+ * scaled about its centre (the CPU composes the blink's spring, the lid's
+ * press and her motion's knock into one scale), turned and drifted a hair on
+ * the spring, brought forward a hair, and rolled about the eye bone with a
+ * closing expression — inside the white, which stays where it is. A highlight
+ * layer (this draw's material is one of jelly[1].w's) takes the iris's move,
+ * then its own scale, turn and tremble, before the roll. Vertices take it by their weight on the eye bones
+ * (jelly[2].w, jelly[3].w), so nothing else on the face moves.
+ */
+fn rzJellyVertex(p: vec3f, joints: vec4<u32>, nw: vec4f) -> vec3f {
+  let j = objectLight.jelly;
+  let ids = u32(j[1].w);
+  let mid = u32(material.materialId);
+  let hl = mid > 0u && (mid == (ids & 4095u) || mid == (ids >> 12u));
+  var out = p;
+  for (var e = 0u; e < 2u; e++) {
+    let bone = j[2u + e].w;
+    if (bone < 0.0) { continue; }
+    let b = u32(bone);
+    let w = dot(nw, select(vec4f(0.0), vec4f(1.0), joints == vec4<u32>(b)));
+    if (w <= 0.0) { continue; }
+    let c = j[e].xyz;
+    // A rig that carries both eyes on one bone: each vertex follows its own side.
+    if (j[2].w == j[3].w && e == 0u && distance(p.xy, j[1].xy) < distance(p.xy, j[0].xy)) { continue; }
+    if (j[2].w == j[3].w && e == 1u && distance(p.xy, j[0].xy) <= distance(p.xy, j[1].xy)) { continue; }
+    let t = j[4u + e];
+    let m = j[6u + e];
+    let h = j[10u + e];
+    var q = _rzJellyTurn((p.xy - c.xy) * t.xy, t.z) + m.xy;
+    // Forward is −Z (MMD faces −Z).
+    var push = h.z;
+    if (hl) {
+      // Sliding over the iris's dome on its own, a highlight sheet a hair in
+      // front of it would sink into it where the dome bulges more and the two
+      // fight for depth; so it comes forward by as far as it slid — a slope of
+      // one, steeper than the dome anywhere it draws.
+      let before = q;
+      q = _rzJellyTurn(q * h.xy, t.w) + m.zw;
+      push += length(q - before);
+    }
+    var moved = vec3f(c.xy + q, p.z - push);
+    let roll = j[8u + e];
+    if (roll.w != 0.0) {
+      let d = moved - roll.xyz;
+      let rd = _rzJellyTurn(d.yz, roll.w);
+      moved = roll.xyz + vec3f(d.x, rd.x, rd.y);
+    }
+    out = mix(p, moved, w);
+  }
+  return out;
+}
+`
+
 export const COMMON_BINDINGS_WGSL = /* wgsl */ `
 
 struct CameraUniforms {
@@ -234,66 +301,7 @@ fn _rzCastShadow(wp: vec3f) -> f32 {
 struct ObjectLight { layers: vec4u, ambient: vec4f, sh: array<vec4f, 9>, fill: vec4f, jelly: array<vec4f, 12> }
 @group(1) @binding(1) var<uniform> objectLight: ObjectLight;
 
-fn _rzJellyTurn(q: vec2f, a: f32) -> vec2f {
-  let c = cos(a);
-  let s = sin(a);
-  return vec2f(c * q.x - s * q.y, s * q.x + c * q.y);
-}
-
-/**
- * Where the jelly puts an iris vertex. The iris is the part of the eye the eye
- * bones carry, so it is moved as a whole, in bind space before skinning:
- * scaled about its centre (the CPU composes the blink's spring, the lid's
- * press and her motion's knock into one scale), turned and drifted a hair on
- * the spring, brought forward a hair, and rolled about the eye bone with a
- * closing expression — inside the white, which stays where it is. A highlight
- * layer (this draw's material is one of jelly[1].w's) takes the iris's move,
- * then its own scale, turn and tremble, before the roll. Vertices take it by their weight on the eye bones
- * (jelly[2].w, jelly[3].w), so nothing else on the face moves.
- */
-fn rzJellyVertex(p: vec3f, joints: vec4<u32>, nw: vec4f) -> vec3f {
-  let j = objectLight.jelly;
-  let ids = u32(j[1].w);
-  let mid = u32(material.materialId);
-  let hl = mid > 0u && (mid == (ids & 4095u) || mid == (ids >> 12u));
-  var out = p;
-  for (var e = 0u; e < 2u; e++) {
-    let bone = j[2u + e].w;
-    if (bone < 0.0) { continue; }
-    let b = u32(bone);
-    let w = dot(nw, select(vec4f(0.0), vec4f(1.0), joints == vec4<u32>(b)));
-    if (w <= 0.0) { continue; }
-    let c = j[e].xyz;
-    // A rig that carries both eyes on one bone: each vertex follows its own side.
-    if (j[2].w == j[3].w && e == 0u && distance(p.xy, j[1].xy) < distance(p.xy, j[0].xy)) { continue; }
-    if (j[2].w == j[3].w && e == 1u && distance(p.xy, j[0].xy) <= distance(p.xy, j[1].xy)) { continue; }
-    let t = j[4u + e];
-    let m = j[6u + e];
-    let h = j[10u + e];
-    var q = _rzJellyTurn((p.xy - c.xy) * t.xy, t.z) + m.xy;
-    // Forward is −Z (MMD faces −Z).
-    var push = h.z;
-    if (hl) {
-      // Sliding over the iris's dome on its own, a highlight sheet a hair in
-      // front of it would sink into it where the dome bulges more and the two
-      // fight for depth; so it comes forward by as far as it slid — a slope of
-      // one, steeper than the dome anywhere it draws.
-      let before = q;
-      q = _rzJellyTurn(q * h.xy, t.w) + m.zw;
-      push += length(q - before);
-    }
-    var moved = vec3f(c.xy + q, p.z - push);
-    let roll = j[8u + e];
-    if (roll.w != 0.0) {
-      let d = moved - roll.xyz;
-      let rd = _rzJellyTurn(d.yz, roll.w);
-      moved = roll.xyz + vec3f(d.x, rd.x, rd.y);
-    }
-    out = mix(p, moved, w);
-  }
-  return out;
-}
-
+${JELLY_VERTEX_WGSL}
 /** The light arriving at a surface of this object facing n: its own ambient
  *  where loaded data gave it one (a stage's probes, a character's), else the
  *  world's. The same polynomial rzWorldAmbient evaluates. */

package/src/shaders/passes/depth-prepass.ts

@@ -27,7 +27,7 @@
 // attachment, and that answer does not exist at import time. The constant could
 // not have taken the outputs at all, which is most of why it did not have them.
 
-import { DISSOLVE_WGSL } from "../materials/common"
+import { DISSOLVE_WGSL, JELLY_VERTEX_WGSL } from "../materials/common"
 import { sceneFsOutWgsl, sceneIdPadWgsl } from "./scene-contract"
 
 export function transparentDepthPrepassWgsl(): string {
@@ -44,13 +44,20 @@ struct MaterialUniforms {
   alpha: f32,
   _skip0: vec4f,
   _skip1: vec4f,
-  _skip2: vec3f,
+  _skip2: f32,
+  materialId: f32,
+  _skip3: f32,
   dissolve: f32,
 };
 
 @group(0) @binding(0) var<uniform> camera: CameraUniforms;
 @group(0) @binding(2) var diffuseSampler: sampler;
 @group(1) @binding(0) var<storage, read> skinMats: array<mat4x4f>;
+// The model's ObjectLight, for its jelly eyes: depth goes down where the colour
+// pass will draw the iris.
+struct ObjectLight { layers: vec4u, ambient: vec4f, sh: array<vec4f, 9>, fill: vec4f, jelly: array<vec4f, 12> }
+@group(1) @binding(1) var<uniform> objectLight: ObjectLight;
+${JELLY_VERTEX_WGSL}
 @group(2) @binding(0) var diffuseTexture: texture_2d<f32>;
 @group(2) @binding(1) var<uniform> material: MaterialUniforms;
 
@@ -74,10 +81,11 @@ struct VSOut {
   @location(3) joints0: vec4<u32>,
   @location(4) weights0: vec4<f32>,
 ) -> VSOut {
-  let pos4 = vec4f(position, 1.0);
   let weightSum = weights0.x + weights0.y + weights0.z + weights0.w;
   let invWeightSum = select(1.0, 1.0 / weightSum, weightSum > 0.0001);
   let w = select(vec4f(1.0, 0.0, 0.0, 0.0), weights0 * invWeightSum, weightSum > 0.0001);
+  var pos4 = vec4f(position, 1.0);
+  if (objectLight.jelly[0].w > 0.0) { pos4 = vec4f(rzJellyVertex(position, joints0, w), 1.0); }
   var skinned = vec4f(0.0);
   for (var i = 0u; i < 4u; i++) {
     skinned += (skinMats[joints0[i]] * pos4) * w[i];

package/src/shaders/passes/outline.ts

@@ -197,12 +197,22 @@ fn safe_normal2(v: vec2f) -> vec2f {
   let w = max(clipPos.w, 1e-4);
   var ndc: vec2f;
   var coverage = 1.0;
+  // The scene's width dial splits around 1×. Above it, it widens the line
+  // before the minimum, as it always has. Below it, it thins the line AFTER
+  // the minimum: a line held at the minimum is drawn that wide and faded, and
+  // it still writes depth across all of it — so a dial at 0.1× or at 0.0001×
+  // left the same 1.5 px ring for whatever drew or read depth after it, and
+  // the dial did nothing visible. Thinned past the minimum instead, the hull
+  // is genuinely sub-pixel, the multisampling covers only what it covers, and
+  // the line fades with the dial and claims depth only where it is.
+  let widen = max(material.widthScale, 1.0);
+  let thin = min(material.widthScale, 1.0);
   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 off = viewNormal.xy * material.edgeSize * widen * 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);
@@ -214,7 +224,7 @@ fn safe_normal2(v: vec2f) -> vec2f {
     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);
+    let nearNdc = viewNormal.xy * (material.edgeSize * widen * outlineNormal.w * 4.0 / refViewport);
     ndc = nearNdc * (min(w, breakDepth) / w);
 
     // Antialiased minimum (the game's _OutlineAntialias): held at the minimum
@@ -228,6 +238,7 @@ fn safe_normal2(v: vec2f) -> vec2f {
       ndc = select(vec2f(0.0), ndc * (minPx / px), px > 1e-6);
     }
   }
+  ndc *= thin;
   output.normal = worldNormal;
   output.coverage = coverage;
   output.position = vec4f(clipPos.xy + ndc * w, clipPos.z, clipPos.w);

package/src/shaders/passes/shadow.ts

@@ -1,4 +1,4 @@
-import { DISSOLVE_WGSL } from "../materials/common"
+import { DISSOLVE_WGSL, JELLY_VERTEX_WGSL } from "../materials/common"
 
 // Shadow map depth pass. Skinned VS + alpha-test FS (depth-only attachment, no
 // color targets): texels where diffuse-texture alpha × material alpha fall below
@@ -21,10 +21,17 @@ struct MaterialDiffuse {
   diffuse: vec4f,
   _skip0: vec4f,
   _skip1: vec4f,
-  _skip2: vec3f,
+  _skip2: f32,
+  materialId: f32,
+  _skip3: f32,
   dissolve: f32,
 };
 @group(1) @binding(1) var<uniform> material: MaterialDiffuse;
+// The model's ObjectLight, for its jelly eyes: the map must hold the iris where
+// the colour pass draws it.
+struct ObjectLight { layers: vec4u, ambient: vec4f, sh: array<vec4f, 9>, fill: vec4f, jelly: array<vec4f, 12> }
+@group(0) @binding(3) var<uniform> objectLight: ObjectLight;
+${JELLY_VERTEX_WGSL}
 
 struct VSOut {
   @builtin(position) position: vec4f,
@@ -38,10 +45,11 @@ struct VSOut {
 
 @vertex fn vs(@location(0) position: vec3f, @location(1) normal: vec3f, @location(2) uv: vec2f,
   @location(3) joints0: vec4<u32>, @location(4) weights0: vec4<f32>) -> VSOut {
-  let pos4 = vec4f(position, 1.0);
   let ws = weights0.x + weights0.y + weights0.z + weights0.w;
   let inv = select(1.0, 1.0 / ws, ws > 0.0001);
   let nw = select(vec4f(1.0,0.0,0.0,0.0), weights0 * inv, ws > 0.0001);
+  var pos4 = vec4f(position, 1.0);
+  if (objectLight.jelly[0].w > 0.0) { pos4 = vec4f(rzJellyVertex(position, joints0, nw), 1.0); }
   var sp = vec4f(0.0);
   for (var i = 0u; i < 4u; i++) { sp += (skinMats[joints0[i]] * pos4) * nw[i]; }
   var out: VSOut;