reze-engine 0.68.4 → 0.68.6

package/src/engine.ts

@@ -428,6 +428,11 @@ export interface MidiNote {
 /** How many character positions an effect can read (viewU[11..14]). Defined
  *  beside the shader that reads them — the layout arithmetic has to agree. */
 const MAX_EFFECT_SUBJECTS = EFFECT_SUBJECTS
+/** The frame's half height (model units) at and past which a camera follow
+ *  takes its full smoothing; closer shots follow more rigidly — see the
+ *  follow in renderWithDelta(). About a full-body shot. */
+const FOLLOW_LAG_FULL_HALF = 8
+
 /** Where a character IS, for an effect that follows them. センター carries a
  *  motion's root movement — walking, jumping — where the model transform only
  *  carries where the model was placed; 全ての親 is the fallback for a model that
@@ -3042,6 +3047,12 @@ export class Engine {
   private cameraFollowSmoothing = 0
   private cameraFollowSeeded = false
   private readonly cameraFollowPos = new Vec3(0, 0, 0)
+  // Turning with the bone (setCameraFollow's `turn`): the bone's facing as yaw
+  // and elevation, eased like the position, whose change each frame is added
+  // to the orbit — so the shot keeps its angle to her face as she turns.
+  private cameraFollowTurn = false
+  private cameraFollowYaw = 0
+  private cameraFollowPitch = 0
   private cameraTargetOffset: Vec3 = new Vec3(0, 0, 0)
 
   private lastFrameTime = performance.now()
@@ -10227,8 +10238,13 @@ export class Engine {
     this.cameraTargetOffset.z = offset?.z ?? 0
   }
 
-  /** Souls-style follow cam: orbit center tracks a model bone each frame. Shorthand for setCameraTarget(model, boneName, offset). */
-  setCameraFollow(model: Model | null, boneName?: string, offset?: Vec3, smoothing?: number): void {
+  /**
+   * Souls-style follow cam: orbit center tracks a model bone each frame.
+   * Shorthand for setCameraTarget(model, boneName, offset). With `turn`, the
+   * orbit also turns with her face (the head bone) — the camera keeps its
+   * angle to her face as she turns and nods, and a drag still orbits on top.
+   */
+  setCameraFollow(model: Model | null, boneName?: string, offset?: Vec3, smoothing?: number, turn?: boolean): void {
     // Panning sets the very thing the follow overwrites each frame, so it is
     // goes to the offset for as long as the shot is riding a bone. See Camera.panSink.
     this.camera.panSink = model !== null ? this.cameraTargetOffset : null
@@ -10244,6 +10260,7 @@ export class Engine {
     // Handheld feel: seconds for the camera to close ~63% of the gap to the
     // bone (exponential, frame-rate independent). 0 = rigid instant follow.
     this.cameraFollowSmoothing = Math.max(0, smoothing ?? 0)
+    this.cameraFollowTurn = turn ?? false
     this.cameraFollowSeeded = false
   }
 
@@ -10405,6 +10422,49 @@ export class Engine {
     }
   }
 
+  /**
+   * The follow's turn: her FACE's direction — the head bone (頭), whatever bone
+   * the position rides, since an eye under eye tracking turns back toward the
+   * camera as the face turns and so never points anywhere new. MMD rests facing
+   * −Z, so forward is its negated third column, placed by the model's
+   * rotation (the followed bone stands in on a rig with no 頭) — as yaw and
+   * elevation, eased by the follow's own lag, and each frame's change added to
+   * the orbit (alpha turns with the yaw, beta with the elevation) and to the
+   * offset (turned about the vertical, so a framing off to her side stays at
+   * her side). Seeds without moving the camera, on the frame the follow is
+   * (re)bound — cameraFollowSeeded, cleared there, is set right after this.
+   */
+  private turnWithFollowBone(m: Model, tau: number, deltaTime: number): void {
+    const w = m.getBoneWorldMatrix("頭") ?? m.getBoneWorldMatrix(this.cameraTargetBoneName)
+    if (!w) return
+    const fwd = new Vec3(-w[8], -w[9], -w[10])
+    Quat.rotateVecInto(m.rotation, fwd, fwd)
+    const len = Math.hypot(fwd.x, fwd.y, fwd.z)
+    if (len < 1e-6) return
+    const yaw = Math.atan2(fwd.x, fwd.z)
+    const pitch = Math.asin(Math.max(-1, Math.min(1, fwd.y / len)))
+    if (!this.cameraFollowSeeded) {
+      this.cameraFollowYaw = yaw
+      this.cameraFollowPitch = pitch
+      return
+    }
+    const wrap = (a: number) => a - 2 * Math.PI * Math.round(a / (2 * Math.PI))
+    const k = tau > 0 ? 1 - Math.exp(-deltaTime / tau) : 1
+    const dYaw = wrap(yaw - this.cameraFollowYaw) * k
+    const dPitch = (pitch - this.cameraFollowPitch) * k
+    this.cameraFollowYaw = wrap(this.cameraFollowYaw + dYaw)
+    this.cameraFollowPitch += dPitch
+    const cam = this.camera
+    cam.alpha += dYaw
+    cam.beta = Math.max(0.01, Math.min(Math.PI - 0.01, cam.beta - dPitch))
+    const o = this.cameraTargetOffset
+    const c = Math.cos(dYaw)
+    const sn = Math.sin(dYaw)
+    const ox = o.x
+    o.x = ox * c + o.z * sn
+    o.z = -ox * sn + o.z * c
+  }
+
   /** True while the orbit target is riding a model bone (setCameraFollow). */
   isCameraFollowing(): boolean {
     return this.cameraTargetModel !== null
@@ -13736,7 +13796,7 @@ export class Engine {
   }
 
   /**
-   * Jelly eyes: her irises flatten and bulge as her lids move, swell as her
+   * Jelly eyes: her irises shrink and spring back as her lids move, swell as her
    * head turns or moves, and wobble back, and shine like a gem — two hard
    * glints, light glowing through the iris, deeper colour. MMD's 果冻眼, on any
    * PMX and under any eye graph. Null stills them again.
@@ -13755,14 +13815,17 @@ export class Engine {
       this.device.queue.writeBuffer(inst.lightBuffer, 0, inst.objectLight)
       return true
     }
-    if (inst.jellyEyes) inst.jellyEyes.strength = clampStrength(options.strength)
+    if (inst.jellyEyes) {
+      inst.jellyEyes.strength = clampStrength(options.strength)
+      inst.jellyEyes.idle = options.idle ?? true
+    }
     else inst.jellyEyes = new JellyEyes(inst.model, options)
     return true
   }
 
   getModelJellyEyes(modelName: string): Required<JellyEyeOptions> | null {
     const jelly = this.modelInstances.get(modelName)?.jellyEyes
-    return jelly ? { strength: jelly.strength } : null
+    return jelly ? { strength: jelly.strength, idle: jelly.idle } : null
   }
 
   getModelCastShadow(modelName: string): boolean {
@@ -17439,8 +17502,16 @@ export class Engine {
           py += pos.y
           pz += pos.z
         }
-        const tau = this.cameraFollowSmoothing
+        // The lag scales with how much the shot holds. Eased, the pivot trails
+        // the bone by its speed × tau — nothing in a full-body shot, but in a
+        // close-up of her eye it is most of the frame, and the eye swims out
+        // of it as she moves. So: the full handheld lag once the frame is
+        // FOLLOW_LAG_FULL_HALF tall (half height, model units — about a
+        // full-body shot), shrinking linearly to rigid as the shot closes in.
+        const half = this.camera.radius * Math.tan(this.camera.fov / 2)
+        const tau = this.cameraFollowSmoothing * Math.min(1, half / FOLLOW_LAG_FULL_HALF)
         const f = this.cameraFollowPos
+        if (this.cameraFollowTurn) this.turnWithFollowBone(m, tau, deltaTime)
         if (tau > 0 && this.cameraFollowSeeded) {
           // Exponential lag toward the bone: the handheld-camera feel. The
           // orbit pivot trails the target and eases in, never snapping.

package/src/jelly-eyes.ts

@@ -3,8 +3,8 @@
 // What every working version of the effect has in common, whether it is keyed
 // by hand in MMD, a pendulum in Live2D, or a jiggle bone in Blender: an INPUT
 // (a blink, a turn), something that REMEMBERS the last frame (a spring), and a
-// cheap OUTPUT. Here the output is the iris's SCALE, in place: it flattens and
-// bulges as a lid moves (opening too), swells as her head turns or moves, and
+// cheap OUTPUT. Here the output is the iris's SCALE, in place: it shrinks and
+// springs back as a lid moves (opening too), swells as her head turns or moves, and
 // wobbles back. It never slides — tried, it read as the iris coming loose. The
 // inputs are her blinks and her head, never her eyes' own turn: eye tracking
 // turns the eyes after the camera, and the camera must not shake the jelly.
@@ -22,6 +22,9 @@ import type { Model } from "./model"
 export interface JellyEyeOptions {
   /** How much the eyes give: 0 still, 1 the intended bounce, up to 2. Default 1. */
   strength?: number
+  /** The idle taps: a ripple every 4–8 s while nothing else moves them.
+   *  Default true; false leaves only what her blinks and motion set off. */
+  idle?: boolean
 }
 
 // The closing morphs, by the names MMD, VRoid and the usual converters give
@@ -32,14 +35,15 @@ const LEFT = ["ウィンク", "ウィンク２", "ｳｨﾝｸ", "ｳｨﾝｸ
 const RIGHT = ["ウィンク右", "ウィンク２右", "ｳｨﾝｸ右", "ｳｨﾝｸ２右", "wink_R", "Wink_R", "blink_R", "Fcl_EYE_Close_R"]
 
 // The squash: how far a closed eye presses the picture, and the spring that
-// follows it — underdamped, so the eye opening overshoots into a stretch and
-// settles in two or three wobbles, the "Duang" the effect is named for.
+// follows it — lightly damped, so one knock ripples: the squash, a rebound past
+// rest, and several smaller wobbles before it settles. One dip and done read as
+// a scale, not a jelly; the ripple is the "Duang" the effect is named for.
 // Only a CHANGE of closure squashes: the eye's closure less a slow follower of
 // it, so a blink squeezes then bounces, while a held half-close (a smile)
 // leaves the iris at rest instead of squashed for as long as she smiles.
 const SQUASH_CLOSED = 0.35
-const SQUASH_HZ = 1.4
-const SQUASH_ZETA = 0.22
+const SQUASH_HZ = 1.8
+const SQUASH_ZETA = 0.08
 const CLOSURE_FOLLOW_S = 0.35
 // The lag: the picture trails the eye's turn and catches up past it. Radians of
 // lag to eye radii of offset; the head's own turn counts for a third, so a
@@ -55,7 +59,7 @@ const LAG_ZETA = 0.4
 const LAG_GAIN = 0.5
 const LAG_MAX = (3 * Math.PI) / 180
 // And never past this many iris radii, whatever the lever, at strength 1.
-const OFFSET_MAX = 0.06
+const OFFSET_MAX = 0.2
 const HEAD_SHARE = 0.35
 // The inertia: the iris has a little mass, hung on a spring from the head, so
 // her own motion — a bob, a step, a sway of the dance — leaves it behind and
@@ -65,11 +69,38 @@ const INERTIA_ZETA = 0.4
 const INERTIA_GAIN = 0.04
 // The jelly's give: the iris never moves, it swells. The lag and the inertia
 // are how hard it is being knocked (in iris radii, as if it could move); that
-// knock grows it a little and it settles in a wobble — the scale bounce on top
-// of the blink's squash. Iris scale per iris radius of knock.
-const PULSE_GAIN = 1.6
-const PULSE_HZ = 1.6
-const PULSE_ZETA = 0.24
+// knock grows it a little and it ripples back, as the squash does — the bounce on top
+// of the blink's squash. Eased, not linear: the swell is PULSE_MAX·tanh(knock /
+// PULSE_REF), so the small steady knocks of a dance still show while a jolt
+// (play from a pause: the head going from still to moving at once) cannot
+// swell it past the cap.
+const PULSE_MAX = 0.07
+const PULSE_REF = 0.006
+// And the same knock squashes it as a blink does — nearly round, on
+// the blink's spring — so her motion reads as plainly as a blink. Eased by the
+// same curve, up to MOTION_SQUASH (a blink's opening gives about 0.2).
+const MOTION_SQUASH = 0.18
+const PULSE_HZ = 2.0
+const PULSE_ZETA = 0.08
+// The idle taps: every 4–8 s, at uneven times, a knock into the
+// same springs her motion drives — the iris dips, bounces and settles, then
+// rests — the way a jelly on a table is never quite still. A steady sine was
+// tried, as size (a zoom) and as wider-then-taller (queasy); a settling tap is
+// what reads as jelly. A tap is a full KNOCK, exactly what her motion gives at
+// its strongest — a gentler nudge was tried and went unnoticed — held for a
+// moment and let go, so it rings through the same springs. The gaps come from
+// a hash of the tap's count, so the scene clock alone decides them and an
+// export taps where the screen did.
+const IDLE_TAP_S = 0.12
+// How hard a tap knocks (motion's strongest is 1) and how far apart they fall:
+// a full knock every 2–4 s read as the iris zooming constantly; rarer, a touch
+// softer, each one reads as a ripple and the eye rests between.
+const IDLE_TAP = 0.6
+const IDLE_GAP: [number, number] = [4, 8]
+const idleGap = (n: number): number => {
+  const x = Math.sin(n * 12.9898 + 78.233) * 43758.5453
+  return IDLE_GAP[0] + (x - Math.floor(x)) * (IDLE_GAP[1] - IDLE_GAP[0])
+}
 // Integration step, and the jump past which a delta is a seek, not time.
 const SUBSTEP = 1 / 240
 const SEEK = 0.25
@@ -106,6 +137,18 @@ interface EyeRest {
   // Iris centre to the eye bone's head: what a turn moves the iris by, per
   // radian.
   lever: number
+  // The vertices it was measured from (empty for a fallback), and the bone
+  // that carries them (−1 when none does).
+  verts: number[]
+  bone: number
+}
+
+// A vertex morph's pull on an iris: the mean offset it gives the iris's
+// vertices at weight 1. Morphs add linearly, so the iris's centre under any
+// mix of them is the rest centre plus these, weighted.
+interface MorphShift {
+  morph: number
+  d: [number, number, number]
 }
 
 const newState = (): EyeState => ({
@@ -123,37 +166,76 @@ const newState = (): EyeState => ({
 
 export class JellyEyes {
   strength: number
+  idle: boolean
+  // Scene time stepped so far, and the idle taps: how many, and when the next.
+  private clock = 0
+  private taps = 0
+  private nextTap = idleGap(0)
+  // The current tap's knock, 1 at the tap and fading over IDLE_TAP_S.
+  private tapKnock = 0
   private readonly rest: [EyeRest, EyeRest]
   private readonly state: [EyeState, EyeState] = [newState(), newState()]
   private readonly morphs: [number[], number[], number[]]
   private readonly eyeBones: [number, number]
   private readonly headBone: number
   private fresh = true
+  // Each iris's centre THIS frame: the rest centre carried by the morphs that
+  // move the iris (a pupil-up, a look-left) — the vertex shader scales the
+  // morphed iris, so a centre left at rest scales it about a point it has
+  // already left, and it drifts off as it shrinks and grows.
+  private readonly shifts: [MorphShift[], MorphShift[]]
+  private readonly centre: [[number, number, number], [number, number, number]]
   private readonly inertia: Inertia = { p: [0, 0, 0], v: [0, 0, 0], head: [0, 0, 0], offset: [0, 0] }
 
   constructor(model: Model, options: JellyEyeOptions) {
     this.strength = clampStrength(options.strength)
+    this.idle = options.idle ?? true
     const bones = model.getSkeleton().bones
     const index = (name: string) => bones.findIndex((b) => b.name === name)
     const both = index("両目")
     const l = index("左目")
     const r = index("右目")
-    this.eyeBones = [l >= 0 ? l : both, r >= 0 ? r : both]
     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)
     this.morphs = [find(BOTH), find(LEFT), find(RIGHT)]
     this.rest = findIrises(model, l, r, both)
+    // The bone that carries each iris, which may be under the eye bone.
+    this.eyeBones = [this.rest[0].bone, this.rest[1].bone]
+    this.shifts = [irisShifts(model, this.rest[0].verts), irisShifts(model, this.rest[1].verts)]
+    this.centre = [[...this.rest[0].centre], [...this.rest[1].centre]]
   }
 
   /** Advance both springs by dt seconds of scene time. */
   step(dt: number, model: Model): void {
     const weights = model.getEffectiveMorphWeights()
+    for (let e = 0; e < 2; e++) {
+      const c = this.centre[e]
+      const r = this.rest[e].centre
+      c[0] = r[0]
+      c[1] = r[1]
+      c[2] = r[2]
+      for (const { morph, d } of this.shifts[e]) {
+        const w = weights[morph] ?? 0
+        if (w === 0) continue
+        c[0] += d[0] * w
+        c[1] += d[1] * w
+        c[2] += d[2] * w
+      }
+    }
     const sum = (list: number[]) => list.reduce((s, i) => s + (weights[i] ?? 0), 0)
     const both = sum(this.morphs[0])
     const closure = [Math.min(1, both + sum(this.morphs[1])), Math.min(1, both + sum(this.morphs[2]))]
     const head = this.headBone >= 0 ? model.getBoneWorldMatrixAt(this.headBone) : null
     const seek = this.fresh || dt > SEEK || dt < 0
+    if (dt > 0) this.clock += dt
+    if (dt > 0) this.tapKnock *= Math.exp(-dt / IDLE_TAP_S)
+    if (seek) this.tapKnock = 0
+    else if (this.idle && this.clock >= this.nextTap) {
+      this.tapKnock = IDLE_TAP
+      this.taps++
+      this.nextTap = this.clock + idleGap(this.taps)
+    }
     this.stepInertia(dt, head, seek)
     for (let e = 0; e < 2; e++) {
       const s = this.state[e]
@@ -167,7 +249,8 @@ export class JellyEyes {
       else s.settled += (s.closure - s.settled) * Math.min(1, dt / CLOSURE_FOLLOW_S)
       // Either way a lid moves squashes — opening too, which is the half of a
       // blink you can see (closing, the lid hides the iris anyway).
-      const squashTarget = SQUASH_CLOSED * Math.abs(s.closure - s.settled)
+      const knock = seek ? 0 : Math.max(this.tapKnock, Math.tanh(Math.hypot(...this.offset(s, e)) / PULSE_REF))
+      const squashTarget = SQUASH_CLOSED * Math.abs(s.closure - s.settled) + MOTION_SQUASH * knock
       if (seek) {
         s.squash = squashTarget
         s.squashV = 0
@@ -180,7 +263,7 @@ export class JellyEyes {
       }
       const steps = Math.ceil(dt / SUBSTEP)
       const h = steps > 0 ? dt / steps : 0
-      const pulseTarget = PULSE_GAIN * Math.hypot(...this.offset(s, e))
+      const pulseTarget = PULSE_MAX * knock
       for (let i = 0; i < steps; i++) {
         s.pulseV += h * spring(s.pulse - pulseTarget, s.pulseV, PULSE_HZ, PULSE_ZETA)
         s.pulse += h * s.pulseV
@@ -201,17 +284,18 @@ export class JellyEyes {
 
   /** Write jelly[0..5] into an ObjectLight copy (floats 48..71). */
   write(o: Float32Array): void {
-    const [L, R] = this.rest
-    o.set([L.centre[0], L.centre[1], L.centre[2], this.strength], 48)
+    const [L, R] = this.centre
+    o.set([L[0], L[1], L[2], this.strength], 48)
     // One scale bounce for both: the mean of the two eyes', so they swell together.
     const pulse = ((this.state[0].pulse + this.state[1].pulse) / 2) * this.strength
-    o.set([R.centre[0], R.centre[1], R.centre[2], pulse], 52)
+    o.set([R[0], R[1], R[2], pulse], 52)
     for (let e = 0; e < 2; e++) {
       const s = this.state[e]
       const rest = this.rest[e]
       o.set([rest.radius[0], rest.radius[1], s.closure, this.eyeBones[e]], 56 + e * 4)
-      // Offset words (65, 66) stay 0: the iris holds its place; only scale.
-      o.set([s.squash * this.strength, 0, 0, s.shine], 64 + e * 4)
+      // Word 65 stays 0 (the iris holds its place; only scale); 66 carries the
+      // scene clock for the gem's twinkles, wrapped so a float keeps it exact.
+      o.set([s.squash * this.strength, 0, this.clock % 1000, s.shine], 64 + e * 4)
     }
   }
 
@@ -311,6 +395,64 @@ function look(eye: Float32Array | null, head: Float32Array | null, out: [number,
 
 const dot = (a: number[], b: number[]) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
 
+/**
+ * The iris out of everything one eye carries: grouped by material, the group
+ * whose centre is nearest the eye bone, and any other group centred on it
+ * (within its own size) — layers of the same eye. Without materials (or a
+ * bone), the set as it came.
+ */
+function irisOnly(model: Model, set: number[], bone: [number, number, number] | null): number[] {
+  const materials = model.getMaterials?.() ?? []
+  const { positions, indices } = model.getGeometry()
+  if (set.length < 3 || !bone || !materials.length || !indices.length) return set
+  const material = new Int32Array(positions.length / 3).fill(-1)
+  let start = 0
+  materials.forEach((m, i) => {
+    for (let k = start; k < start + m.vertexCount; k++) if (material[indices[k]] < 0) material[indices[k]] = i
+    start += m.vertexCount
+  })
+  const groups = new Map<number, number[]>()
+  for (const v of set) {
+    const g = groups.get(material[v])
+    if (g) g.push(v)
+    else groups.set(material[v], [v])
+  }
+  if (groups.size < 2) return set
+  const boxes = [...groups.values()].map((vs) => {
+    let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity
+    for (const v of vs) {
+      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])
+    }
+    return { vs, x: (minX + maxX) / 2, y: (minY + maxY) / 2, size: Math.max(maxX - minX, maxY - minY) / 2 }
+  })
+  const near = boxes.reduce((a, b) => (Math.hypot(b.x - bone[0], b.y - bone[1]) < Math.hypot(a.x - bone[0], a.y - bone[1]) ? b : a))
+  return boxes.filter((b) => Math.hypot(b.x - near.x, b.y - near.y) <= near.size).flatMap((b) => b.vs)
+}
+
+/** Every vertex morph that moves this iris, with the mean offset it gives it. */
+function irisShifts(model: Model, verts: number[]): MorphShift[] {
+  if (!verts.length) return []
+  const inIris = new Set(verts)
+  const out: MorphShift[] = []
+  model.getMorphing().morphs.forEach((m, morph) => {
+    const d: [number, number, number] = [0, 0, 0]
+    for (const o of m.vertexOffsets ?? []) {
+      if (!inIris.has(o.vertexIndex)) continue
+      d[0] += o.positionOffset[0]
+      d[1] += o.positionOffset[1]
+      d[2] += o.positionOffset[2]
+    }
+    d[0] /= verts.length
+    d[1] /= verts.length
+    d[2] /= verts.length
+    if (Math.hypot(...d) > 1e-6) out.push({ morph, d })
+  })
+  return out
+}
+
 /**
  * Each iris in bind space: the vertices the eye bones carry are exactly the
  * part of the eye that turns to look — the iris and pupil — so their centroid
@@ -336,29 +478,71 @@ function findIrises(model: Model, l: number, r: number, both: number): [EyeRest,
   const leftSign = lHead && rHead ? Math.sign(lHead[0] - rHead[0]) || 1 : 1
   const { positions } = model.getGeometry()
   const { joints, weights } = model.getSkinning()
-  const sets: [number[], number[]] = [[], []]
-  const n = positions.length / 3
-  for (let v = 0; v < n; v++) {
-    let wl = 0
-    let wr = 0
-    let wb = 0
-    for (let k = 0; k < 4; k++) {
-      const j = joints[v * 4 + k]
-      const w = weights[v * 4 + k]
-      if (j === l) wl += w
-      else if (j === r) wr += w
-      else if (j === both) wb += w
+  // Which eye each bone turns with: an eye bone, or any bone under one. Rigs
+  // differ in which carries the iris — some hang it on the eye bone itself,
+  // some on its tip (左目先/右目先), which turns with it all the same.
+  const owner = bones.map((_, i) => {
+    for (let b = i; b >= 0; b = bones[b].parentIndex) {
+      if (b === l) return 0
+      if (b === r) return 1
+      if (b === both) return 2
     }
-    if (wl >= 128) sets[0].push(v)
-    else if (wr >= 128) sets[1].push(v)
-    else if (wb >= 128) sets[Math.sign(positions[v * 3]) === leftSign ? 0 : 1].push(v)
+    return -1
+  })
+  // Per side, the vertices and how much iris weight each bone carries: the
+  // heaviest is the one the vertex shader scales by (one bone per eye).
+  //
+  // The per-eye trees first. 両目 is a fallback for rigs that carry both irises
+  // on it alone: where 左目/右目 do carry them, anything hung on 両目 is
+  // something else that turns with the eyes — an expression overlay above them
+  // (blush lines, sparkles) — and split by side it stretches each "iris" past
+  // any iris, so the size check rejects both and the eyes never move.
+  const gather = (useBoth: boolean) => {
+    const sets: [number[], number[]] = [[], []]
+    const n = positions.length / 3
+    for (let v = 0; v < n; v++) {
+      const w3 = [0, 0, 0]
+      for (let k = 0; k < 4; k++) {
+        const o = owner[joints[v * 4 + k]]
+        if (o >= 0) w3[o] += weights[v * 4 + k]
+      }
+      let side: 0 | 1
+      if (w3[0] >= 128) side = 0
+      else if (w3[1] >= 128) side = 1
+      else if (useBoth && w3[2] >= 128) side = Math.sign(positions[v * 3]) === leftSign ? 0 : 1
+      else continue
+      sets[side].push(v)
+    }
+    return sets
+  }
+  let gathered = gather(false)
+  if (gathered[0].length < 3 && gathered[1].length < 3) gathered = gather(true)
+  // Of what turns with an eye, the iris is the mesh nearest its bone, with the
+  // layers stacked on it (an eye white, a highlight sheet over the same disc).
+  // A mesh elsewhere that the eye bones also carry — an expression overlay
+  // above the eyes — is left out, or it stretches the "iris" past any iris.
+  const sets: [number[], number[]] = [irisOnly(model, gathered[0], lHead), irisOnly(model, gathered[1], rHead)]
+  const carried: [Map<number, number>, Map<number, number>] = [new Map(), new Map()]
+  for (const side of [0, 1] as const) {
+    for (const v of sets[side]) {
+      for (let k = 0; k < 4; k++) {
+        const j = joints[v * 4 + k]
+        if (owner[j] >= 0) carried[side].set(j, (carried[side].get(j) ?? 0) + weights[v * 4 + k])
+      }
+    }
+  }
+  const carrier = (side: 0 | 1): number => {
+    let best = -1
+    let most = 0
+    for (const [j, w] of carried[side]) if (w > most) [best, most] = [j, w]
+    return best
   }
   const apart = lHead && rHead ? Math.hypot(lHead[0] - rHead[0], lHead[1] - rHead[1]) : 0
   const fallbackRadius = apart > 0 ? apart * 0.22 : 0.3
-  const rest = (set: number[], bone: [number, number, number] | null, side: number): EyeRest => {
+  const rest = (set: number[], bone: [number, number, number] | null, side: number, carrierBone: number): EyeRest => {
     if (set.length < 3) {
       const c: [number, number, number] = bone ?? [side * fallbackRadius * 2, 0, 0]
-      return { centre: c, radius: [fallbackRadius, fallbackRadius], lever: fallbackRadius * 2 }
+      return { centre: c, radius: [fallbackRadius, fallbackRadius], lever: fallbackRadius * 2, verts: [], bone: -1 }
     }
     let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity, z = 0
     for (const v of set) {
@@ -376,7 +560,7 @@ function findIrises(model: Model, l: number, r: number, both: number): [EyeRest,
     const rx = (maxX - minX) / 2
     const ry = (maxY - minY) / 2
     if (apart > 0 && (rx > apart * 0.6 || ry > apart * 0.8)) {
-      return { centre: bone ?? [side * fallbackRadius * 2, 0, 0], radius: [fallbackRadius, fallbackRadius], lever: fallbackRadius * 2 }
+      return { centre: bone ?? [side * fallbackRadius * 2, 0, 0], radius: [fallbackRadius, fallbackRadius], lever: fallbackRadius * 2, verts: [], bone: -1 }
     }
     const centre: [number, number, number] = [(minX + maxX) / 2, (minY + maxY) / 2, z / set.length]
     const radius: [number, number] = [Math.max(rx, 1e-3), Math.max(ry, 1e-3)]
@@ -384,7 +568,7 @@ function findIrises(model: Model, l: number, r: number, both: number): [EyeRest,
     // still turns its eyes visibly, so read it as a typical eyeball's.
     const r = (radius[0] + radius[1]) / 2
     const lever = Math.max(bone ? Math.hypot(centre[0] - bone[0], centre[1] - bone[1], centre[2] - bone[2]) : 0, r * 1.5)
-    return { centre, radius, lever }
+    return { centre, radius, lever, verts: set, bone: carrierBone }
   }
-  return [rest(sets[0], lHead, leftSign), rest(sets[1], rHead, -leftSign)]
+  return [rest(sets[0], lHead, leftSign, carrier(0)), rest(sets[1], rHead, -leftSign, carrier(1))]
 }