reze-engine 0.68.4 → 0.68.6

package/dist/jelly-eyes.js

@@ -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.
@@ -23,14 +23,15 @@ const BOTH = ["まばたき", "笑い", "はぅ", "blink", "Blink", "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.
+// 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
@@ -46,7 +47,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
@@ -56,11 +57,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 = [4, 8];
+const idleGap = (n) => {
+    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;
@@ -78,30 +106,66 @@ const newState = () => ({
 });
 export class JellyEyes {
     constructor(model, options) {
+        // Scene time stepped so far, and the idle taps: how many, and when the next.
+        this.clock = 0;
+        this.taps = 0;
+        this.nextTap = idleGap(0);
+        // The current tap's knock, 1 at the tap and fading over IDLE_TAP_S.
+        this.tapKnock = 0;
         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);
+        this.idle = options.idle ?? true;
         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);
+        // 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, model) {
         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) => 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];
@@ -117,7 +181,8 @@ export class JellyEyes {
                 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;
@@ -130,7 +195,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;
@@ -150,17 +215,18 @@ export class JellyEyes {
     }
     /** 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);
+        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);
         }
     }
     /** Where the iris sits off rest, in iris radii (right, up): the lag through
@@ -254,6 +320,71 @@ function look(eye, head, out) {
     }
 }
 const dot = (a, b) => 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, set, bone) {
+    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();
+    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, verts) {
+    if (!verts.length)
+        return [];
+    const inIris = new Set(verts);
+    const out = [];
+    model.getMorphing().morphs.forEach((m, morph) => {
+        const d = [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
@@ -280,35 +411,83 @@ function findIrises(model, l, r, both) {
     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;
+    // 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;
+        }
+        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) => {
+        const sets = [[], []];
+        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;
+            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 = [irisOnly(model, gathered[0], lHead), irisOnly(model, gathered[1], rHead)];
+    const carried = [new Map(), new Map()];
+    for (const side of [0, 1]) {
+        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]);
+            }
         }
-        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 carrier = (side) => {
+        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, bone, side) => {
+    const rest = (set, bone, side, carrierBone) => {
         if (set.length < 3) {
             const c = 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) {
@@ -326,7 +505,7 @@ function findIrises(model, l, r, both) {
         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 = [(minX + maxX) / 2, (minY + maxY) / 2, z / set.length];
         const radius = [Math.max(rx, 1e-3), Math.max(ry, 1e-3)];
@@ -334,7 +513,7 @@ function findIrises(model, l, r, both) {
         // 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))];
 }

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,QAsWhC,CAAC;AAwHF,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,QAyZhC,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

@@ -219,7 +219,7 @@ fn _rzCastShadow(wp: vec3f) -> f32 {
 //               [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
+//               [4] left squash, 0, clock, 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;
 
@@ -231,12 +231,14 @@ struct RzJelly {
   w: f32,
   closure: f32,
   shine: f32,
+  /** Scene seconds (wrapped), for the twinkles. */
+  clock: 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,
+ * shrunk about its centre while a lid moves, a little more down than across,
  * 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
@@ -256,10 +258,11 @@ fn rzJellyVertex(p: vec3f, joints: vec4<u32>, nw: vec4f) -> vec3f {
     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));
+    // The squash, nearly round: it shrinks both ways, a little more down than
+    // across, so the iris keeps its circle and only leans oval; and the bounce
+    // both eyes share (jelly[1].w). Held under 1.08 so a swell cannot rise
+    // past the upper lid.
+    let k = clamp(vec2f(1.0 - 0.8 * st.x, 1.0 - st.x) + j[1].w, vec2f(0.78, 0.75), vec2f(1.08, 1.08));
     let moved = c.xy + (p.xy - c.xy) * k;
     out = vec3f(mix(p.xy, moved, w), p.z);
   }
@@ -279,7 +282,7 @@ fn rzJellyEye(rp: vec3f) -> RzJelly {
   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);
+  return RzJelly(a, w, select(j[2].z, j[3].z, right), st.w, j[4].z);
 }
 
 /**
@@ -301,37 +304,85 @@ fn rzJellyGlow(jj: RzJelly, tex: vec3f, alpha: f32, v: vec3f, l: vec3f, sun: vec
     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.
+  // Held in the middle and lower iris: the top of an iris sits under the upper
+  // lid, and a glint there — or its bloom halo — 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);
+  g = g * min(1.0, 0.25 / max(length(g), 1e-6)) - vec2f(0.0, 0.1);
+  g.y = min(g.y, 0.0);
   let aa = max(length(fwidth(jj.src)), 1e-4);
-  let glint = 1.0 - smoothstep(0.16 - aa, 0.16 + aa, distance(jj.src, g));
+  // A star, not only a disc: the disc with two thin rays through it, the
+  // anime sparkle.
+  let dg = jj.src - g;
+  let rays = max(0.0, 1.0 - abs(dg.y) / 0.018) * (1.0 - smoothstep(0.0, 0.34, abs(dg.x)))
+    + max(0.0, 1.0 - abs(dg.x) / 0.018) * (1.0 - smoothstep(0.0, 0.26, abs(dg.y)));
+  let glint = max(1.0 - smoothstep(0.13 - aa, 0.13 + aa, length(dg)), rays * 0.8);
   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);
+  // Bright enough for bloom to catch, not so bright its halo spreads past the
+  // iris onto the lid.
+  let glints = (glint + 0.8 * second) * lit * (1.8 + 0.8 * jj.shine);
+  // Gone as the lid starts down, not only once shut: a half-closed smile puts
+  // the lid right over where the glint sits.
+  let open = 1.0 - smoothstep(0.1, 0.45, 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));
+  let solid = smoothstep(0.5, 0.9, alpha);
+  let onEye = solid * (1.0 - smoothstep(0.05, 0.35, 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));
+  // Out the LOWER iris, always — the anime gem's bright underside — leaning
+  // away from the glint; never up, where its bloom would spill on the lid.
+  let away = normalize(vec2f(-g.x * 0.6, -1.0));
   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;
+  let through = tex * crescent * (2.2 + 1.0 * 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;
+  let vivid = max(tex - vec3f(lum), vec3f(0.0)) * 1.2;
+  // The glass over it: a broad soft sheen across the upper iris, under the
+  // lid line, the dome of a bead catching the room.
+  let dome = (1.0 - smoothstep(0.0, 0.5, distance(jj.src * vec2f(0.8, 1.4), vec2f(0.0, 0.2)))) * 0.45 * lit;
+  // Everything that blooms keeps to the lower iris, so no halo reaches the lid.
+  let lower = 1.0 - smoothstep(-0.05, 0.3, jj.src.y);
+  // The cut: soft facets fanning across the lower iris, light split as a cut
+  // stone splits it, turning slowly.
+  let ang = atan2(jj.src.y, jj.src.x);
+  let facets = pow(0.5 + 0.5 * cos(ang * 7.0 + jj.clock * 0.35), 6.0)
+    * smoothstep(0.3, 0.75, r) * (1.0 - smoothstep(0.82, 0.97, r)) * lower;
+  // The rim: a band of its own colour just inside the iris edge, HDR, which
+  // bloom spreads into a glow around the stone.
+  let rim = smoothstep(0.7, 0.84, r) * (1.0 - smoothstep(0.86, 0.97, r)) * lower;
+  // Twinkles: three specks in the lower iris, each flashing now and then on
+  // the scene clock.
+  var twinkle = 0.0;
+  for (var i = 0; i < 3; i++) {
+    let fi = f32(i);
+    let at = vec2f(0.42 * cos(3.6 + fi * 1.1), -0.25 - 0.18 * fi + 0.1 * sin(fi * 2.3));
+    let flash = pow(max(0.0, sin(jj.clock * (1.3 + 0.37 * fi) + fi * 2.1)), 12.0);
+    twinkle += (1.0 - smoothstep(0.0, 0.05 + aa, distance(jj.src, at))) * flash;
+  }
+  let sparkle = (vec3f(glints + twinkle * 2.0) * onEye
+    + tex * facets * 2.5 * lit * solid * (1.0 + 0.6 * jj.shine));
+  // The soft light (sheen, glow through, colour) needs only the eye's picture.
+  let gem = (sparkle + (vec3f(dome) + through + vivid) * solid) * open * jj.w;
+  // The edge, which jj.w (fading out from 0.85) would hide: the glowing rim
+  // band, and a thin glossy line right at the border — light running round
+  // the stone's edge — all the way round, bright below and dim above, where a
+  // halo would reach the lid. Up to the mesh's edge and no further.
+  let on = select(0.0, 1.0, strength > 0.0) * (1.0 - smoothstep(1.0 - aa, 1.0, r));
+  let edgeLine = smoothstep(0.92, 0.955, r) * (1.0 - smoothstep(0.965, 0.995, r));
+  let edgeLit = mix(0.3, 1.0, lower) * lit * (1.0 + 0.6 * jj.shine);
+  let edge = (tex * rim * 2.0 + vec3f(rim * 0.25)) * lit * (1.0 + 0.6 * jj.shine)
+    + (vec3f(0.55) + tex * 0.8) * edgeLine * edgeLit;
+  let border = edge * solid * open * on;
   // 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);
+  let lift = tex * (0.25 + 0.35 * jj.shine) * select(0.0, 1.0, strength > 0.0);
+  return (gem + border + lift) * min(strength, 1.0);
 }
 
 /** The light arriving at a surface of this object facing n: its own ambient

package/package.json

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