reze-engine 0.68.8 → 0.68.9

package/dist/jelly-eyes.js

@@ -78,23 +78,23 @@ const HL_SCALE_MIN = 0.85;
 const HL_SCALE_MAX = 1.2;
 // The roll: while a closing expression holds, the iris turns about its eye
 // bone's X axis (左目/右目, the eyeball's centre), rolling down with the lid —
-// the angle at weight 1, and simultaneous expressions add. And it comes
-// forward a little (iris radii) with the expression and with the spring, so
-// the roll does not sink it into the white. The MME rolls with the lid
-// exactly, which the lid hides; here the roll follows on a spring of the same
-// pace and decay as the blink's, so as the eye opens the iris swings up past
-// rest and wobbles back, where it can be seen.
+// the angle at weight 1, and simultaneous expressions add. It comes forward
+// only with the spring (iris radii): pushed with the expression as well, a
+// shut eye's iris came through a lid set close in front of it (白里黑子). The MME rolls with the lid
+// exactly, which the lid hides; here the roll follows on a spring twice the
+// blink's pace with its decay, so as the eye opens the iris swings up past rest
+// and wobbles back, where it can be seen. At the blink's own pace it trailed
+// the opening lid and swung a third of an iris past centre: a jump.
 const ROLL = {
     まばたき: -15, blink: -15, Blink: -15, eye_close: -15, Fcl_EYE_Close: -15, はぅ: -15, 笑い: -5,
     ウィンク: -5, ｳｨﾝｸ: -5, wink: -5, Wink: -5, ウィンク２: -15, ｳｨﾝｸ２: -15, blink_L: -15, Fcl_EYE_Close_L: -15,
     ウィンク右: -5, ｳｨﾝｸ右: -5, wink_R: -5, Wink_R: -5, ウィンク２右: -15, ｳｨﾝｸ２右: -15, blink_R: -15, Fcl_EYE_Close_R: -15,
 };
-const ROLL_HZ = SPRING_HZ;
-const ROLL_ZETA = Math.LN2 / HALF_LIFE / (2 * Math.PI * SPRING_HZ);
-// How much of the spring's swing about the expression angle shows: the whole
-// of it carried the iris up most of its radius after a blink.
-const ROLL_SWING = 0.4;
-const PUSH_EXPRESSION = 0.15;
+const ROLL_HZ = 6;
+const ROLL_ZETA = Math.LN2 / HALF_LIFE / (2 * Math.PI * ROLL_HZ);
+// How much of the spring's swing about the expression angle shows: a
+// twenty-fifth of an iris radius past centre after a blink.
+const ROLL_SWING = 0.25;
 const PUSH_ELASTIC = 0.04;
 // A highlight sheet by name, for rigs that keep it on its own material.
 const HIGHLIGHT = /ハイライト|ﾊｲﾗｲﾄ|高光|highlight|hilight|(^|[^a-z])hl([^a-z]|$)/i;
@@ -200,10 +200,23 @@ export class JellyEyes {
         const l = index("左目");
         const r = index("右目");
         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);
+        const all = model.getMorphing().morphs;
+        const names = all.map((m) => m.name);
+        // The weights read are resolved, so a group whose every target is named
+        // (Reze's まばたき is ウィンク２ + ウィンク２右) arrives through its
+        // leaves; counted as well, a blink rolled the iris twice as far.
+        const known = new Set([...BOTH, ...LEFT, ...RIGHT]);
+        const resolved = (i) => {
+            const refs = all[i].groupReferences;
+            return !!refs?.length && refs.every((r) => known.has(names[r.morphIndex]));
+        };
+        const morphIndex = (n) => {
+            const i = names.indexOf(n);
+            return i >= 0 && !resolved(i) ? i : -1;
+        };
+        const find = (list) => list.map(morphIndex).filter((i) => i >= 0);
         this.morphs = [find(BOTH), find(LEFT), find(RIGHT)];
-        const rolls = (list) => list.map((n) => ({ morph: names.indexOf(n), deg: ROLL[n] ?? 0 })).filter((r) => r.morph >= 0 && r.deg !== 0);
+        const rolls = (list) => list.map((n) => ({ morph: morphIndex(n), deg: ROLL[n] ?? 0 })).filter((r) => r.morph >= 0 && r.deg !== 0);
         this.rolls = [rolls([...BOTH, ...LEFT]), rolls([...BOTH, ...RIGHT])];
         this.rest = findIrises(model, l, r, both);
         // The bone that carries each iris, which may be under the eye bone.
@@ -335,7 +348,7 @@ export class JellyEyes {
             const pivot = rest.pivot;
             o.set(pivot ? [pivot[0], pivot[1], pivot[2], (this.roll[e] + (s.roll - this.roll[e]) * ROLL_SWING) * DEG * g] : [0, 0, 0, 0], 80 + e * 4);
             const hs = (k) => Math.max(HL_SCALE_MIN, Math.min(HL_SCALE_MAX, 1 + x * HL_SCALE[k] * g));
-            o.set([hs(0), hs(1), (s.closure * PUSH_EXPRESSION + Math.min(Math.abs(x), SPRING_LIMIT) * PUSH_ELASTIC) * r * g, 0], 88 + e * 4);
+            o.set([hs(0), hs(1), Math.min(Math.abs(x), SPRING_LIMIT) * PUSH_ELASTIC * r * g, 0], 88 + e * 4);
         }
     }
     /** Where the iris sits off rest, in iris radii (right, up): the lag through
@@ -460,6 +473,11 @@ function blink(s, dt) {
  * As draw ids (1-based over the materials that draw, as the engine numbers
  * MaterialUniforms.materialId), at most two. A rig whose highlight is painted
  * into the iris has none, and only the iris moves.
+ *
+ * A layer drawn on vertices an earlier layer already uses is a copy of that
+ * layer (白里黑子's ☆ and ❤ are star and heart irises on the iris's own
+ * vertices), so it moves with it. Slid as a highlight, a copy of the dome sits
+ * in front of the iris on one half, flipping sides with the tremble.
  */
 function findHighlights(model, rest) {
     const materials = model.getMaterials?.() ?? [];
@@ -468,6 +486,7 @@ function findHighlights(model, rest) {
     if (!materials.length || !indices.length || !iris.size)
         return [];
     const layers = [];
+    const used = new Set();
     let start = 0;
     let id = 0;
     for (const m of materials) {
@@ -476,17 +495,24 @@ function findHighlights(model, rest) {
             continue;
         id++;
         let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+        let copy = true;
+        const mine = [];
         for (let k = start; k < start + count; k++) {
             const v = indices[k];
             if (!iris.has(v))
                 continue;
+            if (!used.has(v))
+                copy = false;
+            mine.push(v);
             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]);
         }
         start += count;
-        if (minX <= maxX)
+        for (const v of mine)
+            used.add(v);
+        if (minX <= maxX && !copy)
             layers.push({ id, name: m.name, minX, maxX, minY, maxY });
     }
     const out = [];

package/dist/physics/autofit.d.ts

@@ -0,0 +1,147 @@
+import { type Rigidbody } from "./types";
+import type { Skinning } from "../model";
+/**
+ * Supplementary colliders fitted to the mesh a PMX rigid body fails to cover.
+ *
+ * PMX body proxies are bodies of revolution — 下半身 is a capsule lying
+ * transversely across the hips, so its cross-section is a circle. A pelvis seen
+ * from the side is not a circle, and across every rig measured the butt sits
+ * 0.18–0.71 units OUTSIDE that capsule while the front is flush or inside. That
+ * gap is where a skirt goes through a character: the cloth is resting correctly
+ * on the collider it was given, and the collider stops half a unit short of the
+ * skin.
+ *
+ * A rest offset cannot close it (see RigidBodyStore.restOffset) — it is one
+ * scalar on a radially symmetric shape, and the error is asymmetric. Measured
+ * on 托特's run cycle, the offset that clears the butt is 0.5, which is simply
+ * the size of the missing geometry, and at that value the skirt stands off the
+ * front and hips by the same 0.5.
+ *
+ * So fit the missing piece instead: take each bone-following body's own skinned
+ * vertices, find the ones that escape its shape in a concentrated lobe, and fit
+ * a capsule to that lobe. That is the fix riggers apply by hand, derived from
+ * the mesh rather than guessed.
+ *
+ * Measured on 托特's run cycle, counting butt vertices swallowed by a cloth
+ * body: 32.4 per frame with nothing, 30.9 with a 0.02 rest offset, 12.4 with
+ * this pass, 10.4 with both.
+ */
+export interface AutoFitOptions {
+    /** A vertex counts as protruding past this much (model units). Below it the
+     *  mesh is within authoring tolerance of the proxy and needs no help. */
+    minProtrusion?: number;
+    /**
+     * Ignore vertices further out than this multiple of the source shape's
+     * RADIUS (its smallest characteristic dimension).
+     *
+     * A coarse first cut at keeping hair and loose clothing out — anything
+     * standing further off the proxy than the proxy is wide is not skin. The
+     * discriminator that actually does the work is minConcentration.
+     */
+    maxProtrusionRatio?: number;
+    /** Fewer protruding vertices than this and it is a spike, not a region. */
+    minVertices?: number;
+    /**
+     * Per-axis quantile the fitted lobe's extent is clipped to, each end. A
+     * handful of stray vertices (a weight-painting slip, a seam) would otherwise
+     * stretch the capsule far past the surface everyone can see.
+     */
+    quantile?: number;
+    /** Skip the fit unless the capsule actually reaches this far past what is
+     *  already covered — otherwise it adds solver rows for nothing. */
+    minGain?: number;
+    /** How tightly the kept lobe's outward directions must agree, 0–1. A loose
+     *  sanity check; the real discriminator is minConcentration. */
+    minDirectionality?: number;
+    /** Vertices outside the dominant lobe, by this cosine, are not part of the
+     *  feature being fitted. */
+    lobeCos?: number;
+    /**
+     * How much deeper the fitted lobe must be than protrusion typically is on
+     * this body, averaged over the vertices that protrude at all.
+     *
+     * This is the guard that separates "the proxy is missing a lobe" from "the
+     * proxy is not a proxy for this mesh at all". A pelvis escapes its capsule by
+     * 0.53 at the back and 0.14 at the front, so the back lobe stands well clear
+     * of the average. Hair escapes the skull by a similar depth in every
+     * direction, so its deepest lobe is no deeper than typical and the ratio sits
+     * near 1. See the note at the meanProtrusion computation for what this
+     * deliberately refuses to fit.
+     *
+     * Without it the pass fits the hairstyle — measured on 托特, 頭 reports
+     * 3653 of 4669 vertices outside its capsule, and the fitted shape was a crate
+     * around the whole head. No threshold on depth or vertex count tells those
+     * two cases apart; concentration does.
+     */
+    minConcentration?: number;
+    /**
+     * How many capsules may be fitted to one body, each against what the previous
+     * ones already cover.
+     *
+     * One capsule inscribed in a lobe does not fill it — on 托特's butt a single
+     * fit removed 58% of the clipping and left the rest at the edges the capsule
+     * could not reach. Each further pass re-measures protrusion against the
+     * original shape UNION everything fitted so far, so it lands on whatever is
+     * still exposed instead of re-fitting the same bulge.
+     */
+    maxShapesPerBody?: number;
+    /**
+     * Quantile of the lobe's perpendicular spread used as the capsule radius.
+     *
+     * The clip-versus-float dial, and the one to reach for if a result looks
+     * wrong. Lower hugs the body: less standoff in idle, more clipping left. 1.0
+     * encloses the lobe entirely, which is what produced a visibly hovering
+     * skirt on 托特.
+     */
+    radiusQuantile?: number;
+    /**
+     * Fit only the deepest part of each lobe: points at least this fraction of
+     * the lobe's own maximum protrusion.
+     *
+     * A lobe tapers to nothing at its edges, and a capsule sized to span the
+     * whole thing has to be fat enough to reach the edges too. Fitting the deep
+     * core keeps each capsule small and lets a later pass handle the shallows
+     * with its own, which is both tighter and closer to what the surface is
+     * actually doing.
+     */
+    lobeDepthFraction?: number;
+}
+/** What the pass decided for one source body — surfaced so a rig can be
+ *  inspected rather than silently rebuilt underneath its author. */
+export interface AutoFitResult {
+    /** Index of the body in the input array that this supplements. */
+    sourceIndex: number;
+    sourceName: string;
+    /** Vertices dominated by that body's bone, and how many were outside it. */
+    vertexCount: number;
+    protrudingCount: number;
+    /** Furthest any kept vertex sat outside the source shape. */
+    maxProtrusion: number;
+    /** How far the fitted capsule reaches past what was already covered. */
+    gain: number;
+    /** Length of the kept lobe's mean outward direction, 0–1. */
+    directionality: number;
+    /** Lobe depth over the body's average protrusion. See minConcentration. */
+    concentration: number;
+    /**
+     * Furthest the capsule's newly exposed surface sits from the skin it was
+     * fitted to — the amount cloth resting on it will stand off the body at the
+     * worst point, and the number to watch if a result looks puffy. Only the part
+     * reaching outside the source shape is measured; the rest is buried.
+     */
+    overshoot: number;
+    body: Rigidbody;
+}
+/**
+ * Fit supplementary colliders for every bone-following body whose own mesh
+ * escapes it.
+ *
+ * `vertices` is the model's interleaved vertex buffer (stride 8, position
+ * first) and `skinning` its joints/weights — both in PMX bind pose, the same
+ * space as `shapePosition` / `shapeRotation`, so nothing has to be skinned.
+ *
+ * Returns one entry per body it chose to supplement; the caller appends
+ * `.body` to the rigid body list before constructing RezePhysics.
+ */
+export declare function fitSupplementaryColliders(rigidbodies: Rigidbody[], vertices: Float32Array, skinning: Skinning, options?: AutoFitOptions): AutoFitResult[];
+//# sourceMappingURL=autofit.d.ts.map

package/dist/physics/autofit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autofit.d.ts","sourceRoot":"","sources":["../../src/physics/autofit.ts"],"names":[],"mappings":"AACA,OAAO,EAAiC,KAAK,SAAS,EAAE,MAAM,SAAS,CAAA;AACvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,cAAc;IAC7B;6EACyE;IACzE,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;;;OAOG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,2EAA2E;IAC3E,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;uEACmE;IACnE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;oEACgE;IAChE,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B;gCAC4B;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;;;;;;;;;;;;;OAgBG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;;;;;;;;OASG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB;;;;;;;;;OASG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B;AA2BD;oEACoE;AACpE,MAAM,WAAW,aAAa;IAC5B,kEAAkE;IAClE,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;IAClB,4EAA4E;IAC5E,WAAW,EAAE,MAAM,CAAA;IACnB,eAAe,EAAE,MAAM,CAAA;IACvB,6DAA6D;IAC7D,aAAa,EAAE,MAAM,CAAA;IACrB,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAA;IACZ,6DAA6D;IAC7D,cAAc,EAAE,MAAM,CAAA;IACtB,2EAA2E;IAC3E,aAAa,EAAE,MAAM,CAAA;IACrB;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,SAAS,CAAA;CAChB;AAID;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,SAAS,EAAE,EACxB,QAAQ,EAAE,YAAY,EACtB,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,cAAmB,GAC3B,aAAa,EAAE,CA4CjB"}