reze-engine 0.68.3 → 0.68.4

package/dist/jelly-eyes.js

@@ -0,0 +1,340 @@
+// 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.
+// 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;
+const newState = () => ({
+    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 {
+    constructor(model, options) {
+        this.state = [newState(), newState()];
+        this.fresh = true;
+        this.inertia = { p: [0, 0, 0], v: [0, 0, 0], head: [0, 0, 0], offset: [0, 0] };
+        this.strength = clampStrength(options.strength);
+        const bones = model.getSkeleton().bones;
+        const index = (name) => 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) => 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, model) {
+        const weights = model.getEffectiveMorphWeights();
+        const sum = (list) => 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) {
+        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. */
+    offset(s, e) {
+        const angle = (x) => 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. */
+    stepInertia(dt, head, seek) {
+        const m = this.inertia;
+        if (!head) {
+            m.offset[0] = m.offset[1] = 0;
+            return;
+        }
+        const now = [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) => 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) {
+    o.fill(0, 48, 72);
+}
+export function clampStrength(s) {
+    return Math.max(0, Math.min(2, s ?? 1));
+}
+/** Acceleration of a damped spring at displacement x, velocity v. */
+function spring(x, v, hz, zeta) {
+    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, head, out) {
+    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, b) => 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, l, r, both) {
+    const bones = model.getSkeleton().bones;
+    const head = (i) => {
+        if (i < 0)
+            return null;
+        const p = [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 = [[], []];
+    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, bone, side) => {
+        if (set.length < 3) {
+            const c = 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 = [(minX + maxX) / 2, (minY + maxY) / 2, z / set.length];
+        const radius = [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/dist/shaders/materials/common.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/shaders/materials/common.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,oBAAoB,QAgPhC,CAAC;AAuHF,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAGD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,orMAgHzB,CAAA;AAQD,eAAO,MAAM,4BAA4B,QAC6H,CAAA"}
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/shaders/materials/common.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,oBAAoB,QAsWhC,CAAC;AAwHF,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAGD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,orMAgHzB,CAAA;AAQD,eAAO,MAAM,4BAA4B,QAC6H,CAAA"}

package/dist/shaders/materials/common.js

@@ -213,9 +213,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. */
@@ -322,10 +440,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reze-engine",
-  "version": "0.68.3",
+  "version": "0.68.4",
   "description": "A lightweight WebGPU engine for real-time 3D MMD/PMX model rendering",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/engine.ts

@@ -43,6 +43,7 @@ import {
   type SimClock,
 } from "./effect-schedule"
 import { parentKeySpan, type ModelParentKey } from "./parent-keys"
+import { JellyEyes, clampStrength, clearJellyEyes, type JellyEyeOptions } from "./jelly-eyes"
 import { NativeHost } from "./unity/host"
 import { NativeLooks, type NativeLook } from "./unity/looks"
 import { NativeStage, type NativeStageLights, type NativeStagePackage, type NativeStageReader } from "./unity/stage"
@@ -1004,6 +1005,9 @@ interface ModelInstance {
    *  Off drops every draw from the shadow list; on hands it back to the PMX
    *  flag on each material. */
   castShadow: boolean
+  /** Its jelly eyes' springs, or null while its eyes are still — see
+   *  setModelJellyEyes. */
+  jellyEyes: JellyEyes | null
   basePath: string
   assetReader: AssetReader
   gpuBuffers: GPUBuffer[]
@@ -8311,8 +8315,9 @@ export class Engine {
           visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
           buffer: { type: "read-only-storage" },
         },
-        // The model's own light — see setModelFill and setModelSun.
-        { binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
+        // The model's own light — see setModelFill and setModelSun. VERTEX
+        // too: jelly eyes move the iris in the vertex shader (jelly[] in it).
+        { binding: 1, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
       ],
     })
     // group 2: per-material (textures + material uniforms) — bound per draw call.
@@ -13730,6 +13735,36 @@ export class Engine {
     return true
   }
 
+  /**
+   * Jelly eyes: her irises flatten and bulge 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.
+   *
+   * Driven by her closing morphs (まばたき, the winks) and her head bone, never
+   * her eyes' own turn, so eye tracking following the camera leaves it still.
+   * The springs step on the scene clock, so an export bounces exactly as the
+   * screen did. The iris only scales in place (see jelly-eyes.ts).
+   */
+  setModelJellyEyes(modelName: string, options: JellyEyeOptions | null): boolean {
+    const inst = this.modelInstances.get(modelName)
+    if (!inst || !this.device) return false
+    if (!options) {
+      inst.jellyEyes = null
+      clearJellyEyes(inst.objectLight)
+      this.device.queue.writeBuffer(inst.lightBuffer, 0, inst.objectLight)
+      return true
+    }
+    if (inst.jellyEyes) inst.jellyEyes.strength = clampStrength(options.strength)
+    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
+  }
+
   getModelCastShadow(modelName: string): boolean {
     return this.modelInstances.get(modelName)?.castShadow ?? true
   }
@@ -13800,6 +13835,12 @@ export class Engine {
         verticesChanged = inst.model.update(deltaTime, inst.isStage || inst.isPlane ? false : this.ikEnabled)
         inst.skinMatricesDirty = true
       }
+      // After the pose, so the springs read this frame's blink and eye turn.
+      if (inst.jellyEyes) {
+        inst.jellyEyes.step(deltaTime, inst.model)
+        inst.jellyEyes.write(inst.objectLight)
+        this.device.queue.writeBuffer(inst.lightBuffer, 48 * 4, inst.objectLight, 48, 24)
+      }
       animMs += performance.now() - tAnim
       // Material morphs ride the same weight change as vertex morphs but land in
       // uniform buffers, so they consume their own flag — a model whose only
@@ -15104,9 +15145,9 @@ export class Engine {
 
     // 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] — see
-    // materials/common.ts.
-    const objectLight = new Float32Array(48)
+    // 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(72)
     new Uint32Array(objectLight.buffer)[0] =
       isStage || isPlane || isProp ? RENDERING_LAYER_DEFAULT : (RENDERING_LAYER_DEFAULT | RENDERING_LAYER_CHARACTER) >>> 0
     const lightBuffer = this.device.createBuffer({
@@ -15142,6 +15183,7 @@ export class Engine {
       model,
       simulateWhileHidden: false,
       castShadow: true,
+      jellyEyes: null,
       basePath,
       assetReader,
       gpuBuffers,

package/src/graph/slots.ts

@@ -57,6 +57,16 @@ const EYE_REAR_GATE = `
   }
 `
 
+// Eye's jelly (Engine.setModelJellyEyes): the vertex shader moves the iris
+// itself; the fragment only adds the glints, computed once the lighting context
+// exists and added in the epilogue after the graph. Off, they are zero.
+const PLAIN_SAMPLE = `  let tex_s = textureSample(diffuseTexture, diffuseSampler, input.uv);
+`
+const EYE_JELLY_SAMPLE = `  let rz_jelly = rzJellyEye(input.restPos);
+${PLAIN_SAMPLE}`
+const EYE_JELLY_GLOW = `  let rz_jelly_glow = rzJellyGlow(rz_jelly, tex_color, tex_s.a, v, l, sun, shadow);
+`
+
 // ── Adjust-tier uniforms — fixed 16-vec4f block (256 B) shared by the single material
 // bind group layout; non-graph draws bind a zero buffer. ──
 const STYLE_UNIFORMS_WGSL = `struct StyleUniforms { p: array<vec4f, 16> };
@@ -104,8 +114,7 @@ function prelude(renderClass: RenderClass, alphaMode: AlphaMode, blend: StyleBle
   const flip =
     renderClass === "eye" ? "" : "\n  n = select(-n, n, dot(n, v) >= 0.0);"
   return `@fragment fn fs(input: VertexOutput) -> FSOut {
-  let tex_s = textureSample(diffuseTexture, diffuseSampler, input.uv);
-  // MMD alpha semantics: material alpha × texture alpha.
+${renderClass === "eye" ? EYE_JELLY_SAMPLE : PLAIN_SAMPLE}  // MMD alpha semantics: material alpha × texture alpha.
   let alpha = material.alpha * tex_s.a;
 ${discard}
 
@@ -152,7 +161,7 @@ ${gate}
   // The normal the lamps' diffuse layer is lit by, for a principled walk to
   // compute it on the way (rzLightsDiffuseOnce). n is final from here on.
   _rzLampN = n;
-
+${renderClass === "eye" ? EYE_JELLY_GLOW : ""}
 `
 }
 
@@ -205,7 +214,7 @@ function epilogue(renderClass: RenderClass, alphaMode: AlphaMode, hasOpacity: bo
   // it is emission, not a surface colour, so nothing may ramp or shadow it. Zero
   // on every fragment of every material that is not dissolving, which is what
   // keeps this out of the way of a scene that never uses it.
-  const BURN = ` + RZ_BURN_COLOR * rz_burn`
+  const BURN = ` + RZ_BURN_COLOR * rz_burn${renderClass === "eye" ? " + rz_jelly_glow" : ""}`
   // The scene fog, last, as the game lays it over a lit surface; an
   // emission-only graph takes none (the game's effect shaders have no fog).
   // A premultiplied colour takes its fog premultiplied too: the haze a pane

package/src/index.ts

@@ -220,6 +220,7 @@ export {
  */
 export { EFFECT_MATH_API, PARTICLE_STRUCT_WGSL } from "./shaders/passes/hosted-api"
 export type { EyeTrackingOptions } from "./model"
+export type { JellyEyeOptions } from "./jelly-eyes"
 
 /**
  * The game's own materials (src/unity): a stage package drawn by its translated