reze-engine 0.68.3 → 0.68.5

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,qBAAqB,EACrB,8BAA8B,EAC9B,sBAAsB,EACtB,qBAAqB,EACrB,KAAK,mBAAmB,EACxB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,EACtB,KAAK,yBAAyB,EAC9B,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,uBAAuB,EACvB,yBAAyB,EACzB,KAAK,eAAe,EACpB,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,QAAQ,GACd,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AACvG,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAIzC,OAAO,EAAE,QAAQ,EAAE,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAE/C,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,QAAQ,EAAE,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAIrH,OAAO,EAAE,gBAAgB,EAAE,KAAK,QAAQ,EAAE,KAAK,UAAU,EAAE,MAAM,eAAe,CAAA;AAIhF,OAAO,EACL,YAAY,EACZ,UAAU,EACV,WAAW,EACX,YAAY,EACZ,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,QAAQ,GACd,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAA;AACnE,OAAO,EACL,YAAY,EACZ,aAAa,EACb,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,SAAS,GACf,MAAM,iBAAiB,CAAA;AACxB,YAAY,EACV,WAAW,EACX,SAAS,EACT,SAAS,EACT,YAAY,EACZ,WAAW,EACX,UAAU,GACX,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,aAAa,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAC3E,OAAO,EAAE,cAAc,EAAE,KAAK,WAAW,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC9H,YAAY,EACV,UAAU,EACV,UAAU,EACV,gBAAgB,EAChB,eAAe,EACf,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAA;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAInD,OAAO,EACL,eAAe,EACf,eAAe,EACf,cAAc,EACd,cAAc,EACd,KAAK,gBAAgB,EACrB,KAAK,eAAe,GACrB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EACL,KAAK,EACL,uBAAuB,EACvB,kBAAkB,EAClB,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,KAAK,EACV,KAAK,QAAQ,EACb,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,aAAa,GACnB,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,UAAU,EAAE,MAAM,QAAQ,CAAA;AACrE,YAAY,EACV,aAAa,EACb,oBAAoB,EACpB,iBAAiB,EACjB,UAAU,EACV,YAAY,EACZ,UAAU,EACV,aAAa,EACb,iBAAiB,EACjB,YAAY,GACb,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,oBAAoB,EACpB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,aAAa,GACnB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,qBAAqB,EAAE,KAAK,YAAY,EAAE,KAAK,iBAAiB,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAC5H,OAAO,EACL,GAAG,EACH,iBAAiB,EACjB,wBAAwB,EACxB,mCAAmC,GACpC,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,SAAS,EAAE,4BAA4B,EAAE,KAAK,cAAc,EAAE,KAAK,OAAO,EAAE,MAAM,cAAc,CAAA;AACzG,OAAO,EAAE,SAAS,EAAE,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAGxC,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,QAAQ,GACd,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,eAAe,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAA;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AACvC,YAAY,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAClD,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,KAAK,SAAS,EAAE,KAAK,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAI3F,OAAO,EACL,WAAW,EACX,mBAAmB,EACnB,gBAAgB,EAChB,YAAY,EACZ,kBAAkB,EAClB,WAAW,EACX,oBAAoB,EACpB,cAAc,EACd,uBAAuB,EACvB,qBAAqB,EACrB,oBAAoB,EACpB,yBAAyB,EACzB,qBAAqB,EACrB,oBAAoB,EACpB,aAAa,EACb,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,SAAS,EACd,KAAK,uBAAuB,EAC5B,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,IAAI,EACT,KAAK,SAAS,GACf,MAAM,WAAW,CAAA;AAElB;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACnF,YAAY,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AACjD,YAAY,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAEnD;;;;GAIG;AACH,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAC1E,YAAY,EAAE,UAAU,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAClF,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAClE,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACzE,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA"}

package/dist/jelly-eyes.d.ts

@@ -0,0 +1,37 @@
+import type { Model } from "./model";
+export interface JellyEyeOptions {
+    /** How much the eyes give: 0 still, 1 the intended bounce, up to 2. Default 1. */
+    strength?: number;
+    /** The idle taps: a small bounce every few seconds while nothing else moves them.
+     *  Default true; false leaves only what her blinks and motion set off. */
+    idle?: boolean;
+}
+export declare class JellyEyes {
+    strength: number;
+    idle: boolean;
+    private clock;
+    private taps;
+    private nextTap;
+    private readonly rest;
+    private readonly state;
+    private readonly morphs;
+    private readonly eyeBones;
+    private readonly headBone;
+    private fresh;
+    private readonly inertia;
+    constructor(model: Model, options: JellyEyeOptions);
+    /** Advance both springs by dt seconds of scene time. */
+    step(dt: number, model: Model): void;
+    /** Write jelly[0..5] into an ObjectLight copy (floats 48..71). */
+    write(o: Float32Array): void;
+    /** Where the iris sits off rest, in iris radii (right, up): the lag through
+     *  the eye's lever, plus the inertia. */
+    private offset;
+    /** The mass on the head: semi-implicit steps toward where the head is, the
+     *  head moving linearly across the frame. */
+    private stepInertia;
+}
+/** Zero jelly[0..5] — strength 0 is what the shader reads as off. */
+export declare function clearJellyEyes(o: Float32Array): void;
+export declare function clampStrength(s: number | undefined): number;
+//# sourceMappingURL=jelly-eyes.d.ts.map

package/dist/jelly-eyes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jelly-eyes.d.ts","sourceRoot":"","sources":["../src/jelly-eyes.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpC,MAAM,WAAW,eAAe;IAC9B,kFAAkF;IAClF,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;8EAC0E;IAC1E,IAAI,CAAC,EAAE,OAAO,CAAA;CACf;AA0HD,qBAAa,SAAS;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,OAAO,CAAA;IAEb,OAAO,CAAC,KAAK,CAAI;IACjB,OAAO,CAAC,IAAI,CAAI;IAChB,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAoB;IACzC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiD;IACvE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgC;IACvD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkB;IAC3C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;IACjC,OAAO,CAAC,KAAK,CAAO;IACpB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;gBAEvF,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,eAAe;IAgBlD,wDAAwD;IACxD,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI;IAgEpC,kEAAkE;IAClE,KAAK,CAAC,CAAC,EAAE,YAAY,GAAG,IAAI;IAe5B;6CACyC;IACzC,OAAO,CAAC,MAAM;IAad;iDAC6C;IAC7C,OAAO,CAAC,WAAW;CAkCpB;AAED,qEAAqE;AACrE,wBAAgB,cAAc,CAAC,CAAC,EAAE,YAAY,GAAG,IAAI,CAEpD;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAE3D"}

package/dist/jelly-eyes.js

@@ -0,0 +1,381 @@
+// 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 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.
+//
+// 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 — 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.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
+// 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.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
+// 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 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 few seconds, at uneven times, a small 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. Velocity kicks, so the bounce keeps the springs' own
+// timing; 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_SQUASH_KICK = 0.45;
+const IDLE_PULSE_KICK = 0.25;
+const IDLE_GAP = [1.8, 3.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;
+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) {
+        // 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);
+        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);
+    }
+    /** 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;
+        if (dt > 0)
+            this.clock += dt;
+        let tap = false;
+        if (!seek && this.idle && this.clock >= this.nextTap) {
+            tap = true;
+            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];
+            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 knock = seek ? 0 : 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;
+                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;
+            }
+            if (tap) {
+                s.squashV += IDLE_SQUASH_KICK;
+                s.pulseV -= IDLE_PULSE_KICK;
+            }
+            const steps = Math.ceil(dt / SUBSTEP);
+            const h = steps > 0 ? dt / steps : 0;
+            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;
+                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,QAkXhC,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,139 @@ 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:
+ * 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
+ * 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 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);
+  }
+  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 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.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));
+  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.
+  // 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 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));
+  let crescent = smoothstep(0.15, 0.7, dot(jj.src, away)) * (1.0 - smoothstep(0.8, 1.0, r));
+  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)) * 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;
+  // The glints keep off the iris's top; the soft light (sheen, glow through,
+  // colour) has no halo to spill, so it only needs the eye's own picture.
+  let gem = (vec3f(glints) * onEye + (vec3f(dome) + through + vivid) * solid) * open * 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.25 + 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 +452,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.5",
   "description": "A lightweight WebGPU engine for real-time 3D MMD/PMX model rendering",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",