reze-engine 0.68.3 → 0.68.4

package/src/jelly-eyes.ts

@@ -0,0 +1,390 @@
+// Jelly eyes — the MMD 果冻眼 / Live2D highlight wobble, for any PMX.
+//
+// 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
+// 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.
+//
+// The springs run on the CPU, stepped by the engine's frame delta — the same
+// exact delta renderFrame() hands an export, so a blink bounces identically on
+// screen and in the file. Their state rides in the model's ObjectLight
+// (jelly[0..5], see materials/common.ts): the vertex shader scales the iris —
+// the vertices the eye bones carry — about its centre, and the eye render class
+// adds the gem look after its graph (glints, light through the iris, deeper
+// colour), so every eye graph becomes jelly without knowing it.
+
+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 closing morphs, by the names MMD, VRoid and the usual converters give
+// them. Group morphs (a smile that closes the eyes) resolve into these through
+// the effective weights, so only the leaves need naming.
+const BOTH = ["まばたき", "笑い", "はぅ", "blink", "Blink", "eye_close", "Fcl_EYE_Close"]
+const LEFT = ["ウィンク", "ウィンク２", "ｳｨﾝｸ", "ｳｨﾝｸ２", "wink", "Wink", "blink_L", "Fcl_EYE_Close_L"]
+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.
+// 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 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
+// sudden stop of the head wobbles the eyes without a dance keeping them
+// sloshing.
+const LAG_HZ = 3.5
+const LAG_ZETA = 0.4
+// The lag is an angle: how far the iris trails the eye's own turn, as a share
+// of the lag in look, capped at a quarter of eye tracking's default 20° reach —
+// a wobble on the turn, never a second turn. It becomes iris radii through the
+// eye's own lever (iris centre to eye bone), the same displacement a real turn
+// of that angle gives, so it scales with whatever the rig's eyes do.
+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 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
+// it swings back. Model units of lag to iris radii, scaled by INERTIA_GAIN.
+const INERTIA_HZ = 3.0
+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
+// Integration step, and the jump past which a delta is a seek, not time.
+const SUBSTEP = 1 / 240
+const SEEK = 0.25
+
+interface EyeState {
+  closure: number
+  // The slow follower of closure; closure − settled is what squashes.
+  settled: number
+  squash: number
+  squashV: number
+  // Lagged look (yaw, pitch) and its velocity; the offset is lagged − actual.
+  lag: [number, number]
+  lagV: [number, number]
+  look: [number, number]
+  shine: number
+  pulse: number
+  pulseV: number
+}
+
+// The head's inertial mass, shared by both eyes: where it hangs (world) and how
+// fast it moves, and where the head was last frame.
+interface Inertia {
+  p: [number, number, number]
+  v: [number, number, number]
+  head: [number, number, number]
+  // Its lag in the head's frame, in iris radii: (right, up).
+  offset: [number, number]
+}
+
+interface EyeRest {
+  // The iris in BIND space — where restPos puts it — and its half extents.
+  centre: [number, number, number]
+  radius: [number, number]
+  // Iris centre to the eye bone's head: what a turn moves the iris by, per
+  // radian.
+  lever: number
+}
+
+const newState = (): EyeState => ({
+  closure: 0,
+  settled: 0,
+  squash: 0,
+  squashV: 0,
+  lag: [0, 0],
+  lagV: [0, 0],
+  look: [0, 0],
+  shine: 0,
+  pulse: 0,
+  pulseV: 0,
+})
+
+export class JellyEyes {
+  strength: number
+  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
+  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)
+    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)
+  }
+
+  /** Advance both springs by dt seconds of scene time. */
+  step(dt: number, model: Model): void {
+    const weights = model.getEffectiveMorphWeights()
+    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
+    this.stepInertia(dt, head, seek)
+    for (let e = 0; e < 2; e++) {
+      const s = this.state[e]
+      s.closure = closure[e]
+      // Her HEAD's turn, not her eyes': eye tracking turns the eyes after the
+      // camera, so the eyes' own turn would make the camera shake the jelly.
+      // Only her motion — the head turning and moving (the inertia) — and her
+      // blinks do.
+      look(head, null, s.look)
+      if (seek) s.settled = s.closure
+      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)
+      if (seek) {
+        s.squash = squashTarget
+        s.squashV = 0
+        s.lag[0] = s.look[0]
+        s.lag[1] = s.look[1]
+        s.lagV[0] = s.lagV[1] = 0
+        s.shine = 0
+        s.pulse = s.pulseV = 0
+        continue
+      }
+      const steps = Math.ceil(dt / SUBSTEP)
+      const h = steps > 0 ? dt / steps : 0
+      const pulseTarget = PULSE_GAIN * Math.hypot(...this.offset(s, e))
+      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
+        s.squashV += h * spring(s.squash - squashTarget, s.squashV, SQUASH_HZ, SQUASH_ZETA)
+        s.squash += h * s.squashV
+        for (let k = 0; k < 2; k++) {
+          s.lagV[k] += h * spring(s.lag[k] - s.look[k], s.lagV[k], LAG_HZ, LAG_ZETA)
+          s.lag[k] += h * s.lagV[k]
+        }
+      }
+      // Shine follows the motion: bright while the jelly moves, fading as it
+      // settles, eased so a single wobble does not strobe.
+      const motion = Math.min(1, 2.5 * Math.abs(s.squash - squashTarget) + 4 * Math.hypot(...this.offset(s, e)))
+      s.shine += (motion - s.shine) * Math.min(1, dt * 12)
+    }
+    this.fresh = false
+  }
+
+  /** 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)
+    // 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)
+    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)
+    }
+  }
+
+  /** Where the iris sits off rest, in iris radii (right, up): the lag through
+   *  the eye's lever, plus the inertia. */
+  private offset(s: EyeState, e: number): [number, number] {
+    const angle = (x: number) => Math.max(-LAG_MAX, Math.min(LAG_MAX, x * LAG_GAIN))
+    const rest = this.rest[e]
+    const r = (rest.radius[0] + rest.radius[1]) / 2
+    const per = rest.lever / r
+    const io = this.inertia.offset
+    const x = angle(s.lag[0] - s.look[0]) * per + io[0]
+    const y = angle(s.lag[1] - s.look[1]) * per + io[1]
+    const n = Math.hypot(x, y)
+    const cap = n > OFFSET_MAX ? OFFSET_MAX / n : 1
+    return [x * cap, y * cap]
+  }
+
+  /** The mass on the head: semi-implicit steps toward where the head is, the
+   *  head moving linearly across the frame. */
+  private stepInertia(dt: number, head: Float32Array | null, seek: boolean): void {
+    const m = this.inertia
+    if (!head) {
+      m.offset[0] = m.offset[1] = 0
+      return
+    }
+    const now: [number, number, number] = [head[12], head[13], head[14]]
+    if (seek) {
+      m.p = [...now]
+      m.v = [0, 0, 0]
+      m.head = [...now]
+      m.offset[0] = m.offset[1] = 0
+      return
+    }
+    const hv = [0, 1, 2].map((k) => (dt > 0 ? (now[k] - m.head[k]) / dt : 0))
+    const steps = Math.ceil(dt / SUBSTEP)
+    const h = steps > 0 ? dt / steps : 0
+    for (let i = 1; i <= steps; i++) {
+      const t = i / steps
+      for (let k = 0; k < 3; k++) {
+        const at = m.head[k] + (now[k] - m.head[k]) * t
+        m.v[k] += h * spring(m.p[k] - at, m.v[k] - hv[k], INERTIA_HZ, INERTIA_ZETA)
+        m.p[k] += h * m.v[k]
+      }
+    }
+    m.head = now
+    const u = [m.p[0] - now[0], m.p[1] - now[1], m.p[2] - now[2]]
+    const right = [head[0], head[1], head[2]]
+    const up = [head[4], head[5], head[6]]
+    const size = Math.max(1e-3, (this.rest[0].radius[0] + this.rest[0].radius[1] + this.rest[1].radius[0] + this.rest[1].radius[1]) / 4)
+    const cap = (x: number) => Math.max(-OFFSET_MAX, Math.min(OFFSET_MAX, x))
+    m.offset[0] = cap((dot(u, right) / Math.hypot(...right) / size) * INERTIA_GAIN)
+    m.offset[1] = cap((dot(u, up) / Math.hypot(...up) / size) * INERTIA_GAIN)
+  }
+}
+
+/** Zero jelly[0..5] — strength 0 is what the shader reads as off. */
+export function clearJellyEyes(o: Float32Array): void {
+  o.fill(0, 48, 72)
+}
+
+export function clampStrength(s: number | undefined): number {
+  return Math.max(0, Math.min(2, s ?? 1))
+}
+
+/** Acceleration of a damped spring at displacement x, velocity v. */
+function spring(x: number, v: number, hz: number, zeta: number): number {
+  const w = 2 * Math.PI * hz
+  return -w * w * x - 2 * zeta * w * v
+}
+
+/**
+ * Where an eye looks, as (yaw, pitch) radians: the eye in the head's frame,
+ * plus a share of the head in the model's. Bone matrices are column-major and
+ * MMD rests facing −Z, so forward is the negated third column.
+ */
+function look(eye: Float32Array | null, head: Float32Array | null, out: [number, number]): void {
+  out[0] = out[1] = 0
+  if (!eye) return
+  const f = [-eye[8], -eye[9], -eye[10]]
+  if (head && head !== eye) {
+    const right = [head[0], head[1], head[2]]
+    const up = [head[4], head[5], head[6]]
+    const hf = [-head[8], -head[9], -head[10]]
+    const fz = dot(f, hf)
+    out[0] = Math.atan2(dot(f, right), fz)
+    out[1] = Math.atan2(dot(f, up), fz)
+    out[0] += HEAD_SHARE * Math.atan2(hf[0], -hf[2])
+    out[1] += HEAD_SHARE * Math.asin(Math.max(-1, Math.min(1, hf[1] / Math.hypot(hf[0], hf[1], hf[2]))))
+  } else {
+    // Yaw positive toward +X, as in the head-frame branch: the shader warps
+    // along bind-space +X, so the two must agree.
+    out[0] = Math.atan2(f[0], -f[2])
+    out[1] = Math.asin(Math.max(-1, Math.min(1, f[1] / Math.hypot(f[0], f[1], f[2]))))
+  }
+}
+
+const dot = (a: number[], b: number[]) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
+
+/**
+ * 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
+ * is its centre and their spread its size. A rig that carries both eyes on
+ * 両目 alone is split by side. With no carried vertices at all, the eye bones'
+ * own heads stand in, sized from how far apart they are.
+ */
+function findIrises(model: Model, l: number, r: number, both: number): [EyeRest, EyeRest] {
+  const bones = model.getSkeleton().bones
+  const head = (i: number): [number, number, number] | null => {
+    if (i < 0) return null
+    const p: [number, number, number] = [0, 0, 0]
+    for (let b = i; b >= 0; b = bones[b].parentIndex) {
+      p[0] += bones[b].bindTranslation[0]
+      p[1] += bones[b].bindTranslation[1]
+      p[2] += bones[b].bindTranslation[2]
+    }
+    return p
+  }
+  const lHead = head(l)
+  const rHead = head(r)
+  // +X is the model's left; trust the bones when they say otherwise.
+  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
+    }
+    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)
+  }
+  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 => {
+    if (set.length < 3) {
+      const c: [number, number, number] = bone ?? [side * fallbackRadius * 2, 0, 0]
+      return { centre: c, radius: [fallbackRadius, fallbackRadius], lever: fallbackRadius * 2 }
+    }
+    let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity, z = 0
+    for (const v of set) {
+      const x = positions[v * 3]
+      const y = positions[v * 3 + 1]
+      minX = Math.min(minX, x)
+      maxX = Math.max(maxX, x)
+      minY = Math.min(minY, y)
+      maxY = Math.max(maxY, y)
+      z += positions[v * 3 + 2]
+    }
+    // A carried set wider than the gap between the eyes is not an iris (a
+    // whole-face rig weighted to the eye bone): fall back rather than wobble
+    // half the face.
+    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 }
+    }
+    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)]
+    // An eye bone sitting on the iris itself would give no lever; such a rig
+    // 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 [rest(sets[0], lHead, leftSign), rest(sets[1], rHead, -leftSign)]
+}

package/src/shaders/materials/common.ts

@@ -216,9 +216,127 @@ fn _rzCastShadow(wp: vec3f) -> f32 {
 //   sh        that ambient's irradiance, folded as the world's (ibl.ts);
 //   fill.rgb  its fill (Engine.setModelFill), added after its graph times its
 //             surface colour — zero for a model that has none.
-struct ObjectLight { layers: vec4u, ambient: vec4f, sh: array<vec4f, 9>, fill: vec4f }
+//   jelly     its jelly eyes (Engine.setModelJellyEyes, jelly-eyes.ts), not
+//             lighting but per-model all the same, so it rides here:
+//               [0] left iris centre (bind space), strength — 0 is off
+//               [1] right iris centre, scale bounce (both eyes)
+//               [2] left iris half extents, closure, eye bone (−1 none)
+//               [3] the right's
+//               [4] left squash, 0, 0, shine             [5] the right's
+struct ObjectLight { layers: vec4u, ambient: vec4f, sh: array<vec4f, 9>, fill: vec4f, jelly: array<vec4f, 6> }
 @group(1) @binding(1) var<uniform> objectLight: ObjectLight;
 
+/** What the glints need to know about a fragment of the eye render class. */
+struct RzJelly {
+  /** Where in the iris this fragment is, in iris radii. */
+  src: vec2f,
+  /** 1 inside the iris, easing to 0 at its rim (0 everywhere when off). */
+  w: f32,
+  closure: f32,
+  shine: f32,
+};
+
+/**
+ * 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:
+ * flattened about its centre while the eye closes, bulging across as jelly does,
+ * grown past rest as it springs back, and swelling as a turn or her motion
+ * knocks it — scale only, in place, inside the white, which stays where it is. 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;
+  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 st = j[4u + e];
+    // The blink's squash, as jelly gives: flattened down, it bulges across
+    // (and a stretch thins it), and the bounce both eyes share (jelly[1].w).
+    // Height is held under 1.06 so a swell cannot rise past the upper lid.
+    let k = clamp(vec2f(1.0 + 0.45 * st.x, 1.0 - st.x) + j[1].w, vec2f(0.9, 0.78), vec2f(1.1, 1.06));
+    let moved = c.xy + (p.xy - c.xy) * k;
+    out = vec3f(mix(p.xy, moved, w), p.z);
+  }
+  return out;
+}
+
+/**
+ * The glints' frame for an eye fragment: its place in the iris in iris radii,
+ * from the bind-space position, which the jelly moved the iris with — so the
+ * glints ride the sloshing iris. Strength 0 gives w 0, which turns them off.
+ */
+fn rzJellyEye(rp: vec3f) -> RzJelly {
+  let j = objectLight.jelly;
+  let qL = (rp.xy - j[0].xy) / max(j[2].xy, vec2f(1e-4));
+  let qR = (rp.xy - j[1].xy) / max(j[3].xy, vec2f(1e-4));
+  let right = dot(qR, qR) < dot(qL, qL);
+  let a = select(qL, qR, right);
+  let st = select(j[4], j[5], right);
+  let w = (1.0 - smoothstep(0.85, 1.0, length(a))) * select(0.0, 1.0, j[0].w > 0.0);
+  return RzJelly(a, w, select(j[2].z, j[3].z, right), st.w);
+}
+
+/**
+ * The jelly shine, added after the graph: two hard glints where the light
+ * would catch a bead — placed by the half vector in the head's frame, so they
+ * hold still while the iris turns under them — and the eye brightening while
+ * it wobbles. Flat, cel discs rather than a gradient lobe; HDR, so bloom
+ * takes them. Shut eyes catch nothing.
+ */
+fn rzJellyGlow(jj: RzJelly, tex: vec3f, alpha: f32, v: vec3f, l: vec3f, sun: vec3f, shadow: f32) -> vec3f {
+  let strength = objectLight.jelly[0].w;
+  var right = vec3f(1.0, 0.0, 0.0);
+  var up = vec3f(0.0, 1.0, 0.0);
+  var fwd = vec3f(0.0, 0.0, -1.0);
+  if (material.headBoneIndex >= 0.0) {
+    let hm = skinMats[u32(material.headBoneIndex)];
+    right = normalize(hm[0].xyz);
+    up = normalize(hm[1].xyz);
+    fwd = -normalize(hm[2].xyz);
+  }
+  let h = normalize(l + v);
+  // Held near the middle of the iris, a little low: the top of an iris sits
+  // under the upper lid, and a glint there pokes out over it.
+  var g = vec2f(dot(h, right), dot(h, up)) * 0.6;
+  g = g * min(1.0, 0.3 / max(length(g), 1e-6)) - vec2f(0.0, 0.08);
+  let aa = max(length(fwidth(jj.src)), 1e-4);
+  let glint = 1.0 - smoothstep(0.16 - aa, 0.16 + aa, distance(jj.src, g));
+  let second = 1.0 - smoothstep(0.07 - aa, 0.07 + aa, distance(jj.src, -0.55 * g + vec2f(0.1, -0.12)));
+  let facing = saturate(dot(fwd, v) * 2.0);
+  let key = clamp(dot(sun, vec3f(0.2126, 0.7152, 0.0722)), 0.3, 2.0);
+  let lit = facing * key * (0.35 + 0.65 * shadow);
+  // HDR, well past 1, so bloom takes them as the hard sparkle of a gem.
+  let glints = (glint + 0.8 * second) * lit * (2.6 + 1.6 * jj.shine);
+  let open = 1.0 - smoothstep(0.3, 0.8, jj.closure);
+  // Only where the eye's own picture is (its alpha), never on the iris's top
+  // rim, and gone as the lid comes down.
+  let onEye = smoothstep(0.5, 0.9, alpha) * (1.0 - smoothstep(0.35, 0.6, jj.src.y));
+  // Light through the jelly: the light enters where the glint is and comes out
+  // the far side, so the iris glows in its own colour in a crescent opposite
+  // the glint — the lit-from-within look of a gem, or a jelly.
+  let r = length(jj.src);
+  let away = -normalize(g + vec2f(0.0, -1e-3));
+  let crescent = smoothstep(0.15, 0.7, dot(jj.src, away)) * (1.0 - smoothstep(0.8, 1.0, r));
+  let through = tex * crescent * (0.9 + 0.6 * jj.shine) * lit;
+  // And the colour runs deeper: the iris's own hue pushed, never its greys.
+  let lum = dot(tex, vec3f(0.2126, 0.7152, 0.0722));
+  let vivid = max(tex - vec3f(lum), vec3f(0.0)) * 0.7;
+  let gem = (vec3f(glints) + through + vivid) * open * onEye * jj.w;
+  // The whole eye shines a little brighter, more while it wobbles — not just
+  // the iris, so this one is not held to it (jj.w).
+  let lift = tex * (0.15 + 0.35 * jj.shine) * select(0.0, 1.0, strength > 0.0);
+  return (gem + lift) * min(strength, 1.0);
+}
+
 /** 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. */
@@ -329,10 +447,11 @@ const COMMON_VS_WGSL = /* wgsl */ `
   var output: VertexOutput;
   output.vcolor = vcolor;
   output.uv2 = uv2;
-  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 nw = 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, nw), 1.0); }
   var skinnedPos = vec4f(0.0);
   var skinnedNrm = vec3f(0.0);
   for (var i = 0u; i < 4u; i++) {

package/dist/graph/presets/pool_floor.d.ts

@@ -1,3 +0,0 @@
-import type { ShaderGraph } from "../schema";
-export declare const POOL_FLOOR_GRAPH: ShaderGraph;
-//# sourceMappingURL=pool_floor.d.ts.map

package/dist/graph/presets/pool_floor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pool_floor.d.ts","sourceRoot":"","sources":["../../../src/graph/presets/pool_floor.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,eAAO,MAAM,gBAAgB,EAAE,WA6B9B,CAAA"}

package/dist/graph/presets/pool_floor.js

@@ -1,42 +0,0 @@
-// Pool floor — the tiled bottom seen through water, with caustics on it.
-//
-// The other half of a pool, and the half that does most of the work. A water
-// surface can be tuned for a long time without the shot reading as a pool;
-// putting the focused-light web on the FLOOR is what settles it, because that
-// is the cue a photograph actually carries. It is a floor material, so it is
-// applied to the tile under the water rather than to the water itself.
-//
-// Caustics land between the albedo and the shading deliberately: they are
-// light, so they should still be dimmed by the floor's own shadow rather than
-// glowing through it. That is the difference between water-focused sun and a
-// decal.
-export const POOL_FLOOR_GRAPH = {
-    version: 1,
-    name: "Pool floor",
-    tags: ["stage", "water", "pool"],
-    nodes: [
-        { id: "tex", type: "texture" },
-        { id: "mat", type: "material_diffuse" },
-        { id: "base", type: "mix/multiply", inputs: { fac: 1.0 } },
-        { id: "caust", type: "caustics" },
-        {
-            id: "principled",
-            type: "principled",
-            inputs: { metallic: 0.0, specular_ior_level: 0.4, roughness: 0.45, spec_clamp: 10.0, sheen_weight: 0.0, sheen_tint: 0.0 },
-        },
-    ],
-    links: [
-        { from: { node: "tex", socket: "color" }, to: { node: "base", socket: "a" } },
-        { from: { node: "mat", socket: "color" }, to: { node: "base", socket: "b" } },
-        { from: { node: "base", socket: "color" }, to: { node: "caust", socket: "color" } },
-        { from: { node: "caust", socket: "color" }, to: { node: "principled", socket: "base_color" } },
-    ],
-    output: { node: "principled", socket: "color" },
-    params: [
-        { id: "tint", label: "Light tint", target: { node: "caust", socket: "tint" }, kind: "color", default: [1.0, 1.0, 1.0] },
-        { id: "scale", label: "Caustic scale", target: { node: "caust", socket: "scale" }, kind: "float", min: 0.01, max: 1, default: 0.12 },
-        { id: "speed", label: "Caustic speed", target: { node: "caust", socket: "speed" }, kind: "float", min: 0, max: 1, default: 0.15 },
-        { id: "strength", label: "Caustic strength", target: { node: "caust", socket: "strength" }, kind: "float", min: 0, max: 3, default: 0.6 },
-        { id: "fade", label: "Depth fade", target: { node: "caust", socket: "fade" }, kind: "float", min: 1, max: 200, default: 30 },
-    ],
-};

package/dist/graph/presets/water.d.ts

@@ -1,3 +0,0 @@
-import type { ShaderGraph } from "../schema";
-export declare const WATER_GRAPH: ShaderGraph;
-//# sourceMappingURL=water.d.ts.map

package/dist/graph/presets/water.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"water.d.ts","sourceRoot":"","sources":["../../../src/graph/presets/water.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,eAAO,MAAM,WAAW,EAAE,WAgBzB,CAAA"}

package/dist/graph/presets/water.js

@@ -1,31 +0,0 @@
-// Water — a planar reflection, rippled, seen through Fresnel.
-//
-// Put a stage's water materials in a style group carrying this graph and the
-// pool starts reflecting. The reflection itself is the engine's mirror pass,
-// which this is the only graph to read; everything else here is the shaping
-// that keeps it from reading as a mirror laid flat in the floor.
-//
-// The exposed params are the ones worth a slider while judging a shot. Scale
-// and speed are the ripple; a real pool's surface is slow and broad, so both
-// defaults sit low. Tint is the water's own colour — a game rip carries that
-// in its material, and the converter hands it straight over.
-//
-// How see-through the water is belongs to the MATERIAL's alpha, not to this
-// graph, which is where every other group's coverage comes from too.
-export const WATER_GRAPH = {
-    version: 1,
-    name: "Water",
-    tags: ["water", "stage"],
-    nodes: [{ id: "water", type: "water" }],
-    links: [],
-    output: { node: "water", socket: "color" },
-    params: [
-        { id: "tint", label: "Tint", target: { node: "water", socket: "tint" }, kind: "color", default: [0.04, 0.62, 0.66] },
-        { id: "scale", label: "Ripple scale", target: { node: "water", socket: "scale" }, kind: "float", min: 0.01, max: 1, default: 0.18 },
-        { id: "speed", label: "Ripple speed", target: { node: "water", socket: "speed" }, kind: "float", min: 0, max: 1, default: 0.12 },
-        { id: "strength", label: "Ripple depth", target: { node: "water", socket: "strength" }, kind: "float", min: 0, max: 2, default: 0.7 },
-        { id: "blur", label: "Reflection blur", target: { node: "water", socket: "blur" }, kind: "float", min: 0, max: 1, default: 0.25 },
-        { id: "mirroring", label: "Mirroring", target: { node: "water", socket: "mirroring" }, kind: "float", min: 0, max: 1, default: 0.20 },
-        { id: "sparkle", label: "Sparkle", target: { node: "water", socket: "sparkle" }, kind: "float", min: 0, max: 4, default: 1.0 },
-    ],
-};