reze-engine 0.67.0 → 0.68.0

package/dist/physics/autofit.js

@@ -0,0 +1,501 @@
+import { Vec3, Quat, Mat4 } from "../math";
+import { RigidbodyShape, RigidbodyType } from "./types";
+const DEFAULTS = {
+    minProtrusion: 0.05,
+    maxProtrusionRatio: 1.0,
+    minVertices: 24,
+    quantile: 0.02,
+    minGain: 0.1,
+    minDirectionality: 0.5,
+    lobeCos: 0.5,
+    minConcentration: 1.3,
+    maxShapesPerBody: 3,
+    radiusQuantile: 0.5,
+    lobeDepthFraction: 0.45,
+};
+const VERTEX_STRIDE = 8;
+/**
+ * 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 function fitSupplementaryColliders(rigidbodies, vertices, skinning, options = {}) {
+    const opt = { ...DEFAULTS, ...options };
+    const vertexCount = vertices.length / VERTEX_STRIDE;
+    if (vertexCount === 0)
+        return [];
+    // Bucket vertices by their dominant bone once. Every body then reads only the
+    // mesh it stands in for, instead of the pass being O(bodies × vertices).
+    const byBone = new Map();
+    for (let i = 0; i < vertexCount; i++) {
+        let bestW = -1;
+        let bestB = -1;
+        for (let k = 0; k < 4; k++) {
+            const w = skinning.weights[i * 4 + k];
+            if (w > bestW) {
+                bestW = w;
+                bestB = skinning.joints[i * 4 + k];
+            }
+        }
+        if (bestB < 0)
+            continue;
+        const list = byBone.get(bestB);
+        if (list === undefined)
+            byBone.set(bestB, [i]);
+        else
+            list.push(i);
+    }
+    const out = [];
+    for (let b = 0; b < rigidbodies.length; b++) {
+        const rb = rigidbodies[b];
+        // Only bone-following proxies. A dynamic body IS the cloth — it has no
+        // skinned surface of its own to escape from.
+        if (rb.type === RigidbodyType.Dynamic && rb.mass > 0)
+            continue;
+        if (rb.boneIndex < 0)
+            continue;
+        const owned = byBone.get(rb.boneIndex);
+        if (owned === undefined || owned.length < opt.minVertices)
+            continue;
+        // Fit repeatedly, each pass measuring against what the earlier ones cover.
+        const covered = [];
+        for (let pass = 0; pass < opt.maxShapesPerBody; pass++) {
+            const fitted = fitOne(rb, b, owned, vertices, opt, covered);
+            if (fitted === null)
+                break;
+            covered.push(fitted.local);
+            out.push(fitted.result);
+        }
+    }
+    return out;
+}
+// Scratch, reused across bodies.
+const _local = [];
+function fitOne(rb, index, owned, vertices, opt, covered) {
+    const q = Quat.fromEuler(rb.shapeRotation.x, rb.shapeRotation.y, rb.shapeRotation.z);
+    const radius = shapeRadius(rb);
+    if (radius <= 0)
+        return null;
+    const maxProtrusion = radius * opt.maxProtrusionRatio;
+    // Collect protruding vertices in the SOURCE BODY's local frame. Working in
+    // that frame rather than the bone's means the fitted box inherits the
+    // proxy's own orientation, which is already aligned with the limb — no
+    // covariance fit, and no second convention to keep straight.
+    //
+    // Each one is stored with the direction it escapes in (the gradient of the
+    // signed distance), because which way the mesh escapes is what decides
+    // whether this is a feature worth fitting at all.
+    _local.length = 0;
+    let deepest = 0;
+    let seedX = 0, seedY = 1, seedZ = 0;
+    let sumProtrusion = 0;
+    for (let n = 0; n < owned.length; n++) {
+        const o = owned[n] * VERTEX_STRIDE;
+        _v.x = vertices[o] - rb.shapePosition.x;
+        _v.y = vertices[o + 1] - rb.shapePosition.y;
+        _v.z = vertices[o + 2] - rb.shapePosition.z;
+        // Into the body's local frame: rotate by the conjugate.
+        Quat.rotateVecInvInto(q, _v, _r);
+        const px = _r.x, py = _r.y, pz = _r.z;
+        const sd = coveredSignedDistance(rb, covered, px, py, pz);
+        if (sd <= opt.minProtrusion || sd > maxProtrusion)
+            continue;
+        coveredOutwardDir(rb, covered, px, py, pz, _r);
+        // Seed the lobe on the DEEPEST vertex, not the mean direction. A pelvis
+        // escapes its capsule at the back by 0.53 and at the front by 0.14, so the
+        // mean cancels below any usable threshold and the butt — the whole point —
+        // is never fitted. The deepest point is always ON the feature.
+        if (sd > deepest) {
+            deepest = sd;
+            seedX = _r.x;
+            seedY = _r.y;
+            seedZ = _r.z;
+        }
+        sumProtrusion += sd;
+        _local.push(px, py, pz, _r.x, _r.y, _r.z, sd);
+    }
+    let found = _local.length / 7;
+    if (found < opt.minVertices)
+        return null;
+    // Averaged over the PROTRUDING vertices, deliberately — the question being
+    // asked is "is the deepest lobe deeper than protrusion typically is on this
+    // body", which is exactly the test that separates a butt from a hairstyle.
+    //
+    // Averaging over all the body's vertices instead was tried and is worse: it
+    // lifts every ratio, and measured on 托特 it scored the head's hair (2.4–4.2)
+    // ABOVE the pelvis (2.85), so no threshold could separate them and the pass
+    // fitted 33 bodies including three around the hair.
+    //
+    // The known blind spot is a mesh that escapes in exactly one place at uniform
+    // depth: the lobe IS the whole protruding set, so the ratio is 1 and nothing
+    // is fitted. Real skin always has a gradient, and for a pass that adds bodies
+    // to someone else's rig, declining when the evidence is ambiguous is the
+    // right way to be wrong.
+    const meanProtrusion = sumProtrusion / found;
+    // Settle the lobe axis: take everything within lobeCos of the seed, recentre
+    // on that set's depth-weighted mean direction, repeat. Two passes is enough —
+    // the seed already sits on the feature, this only centres it.
+    let mdx = seedX, mdy = seedY, mdz = seedZ;
+    for (let pass = 0; pass < 2; pass++) {
+        let ax = 0, ay = 0, az = 0;
+        for (let i = 0; i < found; i++) {
+            const s = i * 7;
+            if (_local[s + 3] * mdx + _local[s + 4] * mdy + _local[s + 5] * mdz < opt.lobeCos)
+                continue;
+            const wgt = _local[s + 6];
+            ax += _local[s + 3] * wgt;
+            ay += _local[s + 4] * wgt;
+            az += _local[s + 5] * wgt;
+        }
+        const len = Math.sqrt(ax * ax + ay * ay + az * az);
+        if (len < 1e-9)
+            break;
+        mdx = ax / len;
+        mdy = ay / len;
+        mdz = az / len;
+    }
+    // Keep only the lobe. Fitting the whole protruding shell would wrap the limb
+    // and put box corners out in open air on the side that was already covered.
+    // Depth floor for the lobe's core, relative to the deepest point IN the lobe
+    // (not the body's overall deepest, which may sit in a different direction).
+    let lobeDeepest = 0;
+    for (let i = 0; i < found; i++) {
+        const s = i * 7;
+        if (_local[s + 3] * mdx + _local[s + 4] * mdy + _local[s + 5] * mdz < opt.lobeCos)
+            continue;
+        if (_local[s + 6] > lobeDeepest)
+            lobeDeepest = _local[s + 6];
+    }
+    const depthFloor = lobeDeepest * opt.lobeDepthFraction;
+    let w = 0;
+    let lobeSum = 0;
+    let dirX = 0, dirY = 0, dirZ = 0;
+    for (let i = 0; i < found; i++) {
+        const s = i * 7;
+        if (_local[s + 3] * mdx + _local[s + 4] * mdy + _local[s + 5] * mdz < opt.lobeCos)
+            continue;
+        if (_local[s + 6] < depthFloor)
+            continue;
+        lobeSum += _local[s + 6];
+        dirX += _local[s + 3];
+        dirY += _local[s + 4];
+        dirZ += _local[s + 5];
+        _local[w * 3 + 0] = _local[s + 0];
+        _local[w * 3 + 1] = _local[s + 1];
+        _local[w * 3 + 2] = _local[s + 2];
+        w++;
+    }
+    found = w;
+    if (found < opt.minVertices)
+        return null;
+    // Concentration: is this lobe actually a FEATURE, or is the whole mesh
+    // uniformly outside its proxy? Hair around a skull escapes by a similar depth
+    // in every direction, so its deepest lobe is no deeper than typical and the
+    // ratio sits near 1. A butt is markedly deeper than the pelvis average. This
+    // is what stops the pass from boxing a hairstyle.
+    //
+    // Only the FIRST pass is judged on it. The question it answers — is this
+    // proxy standing in for this mesh at all — is settled once per body. Later
+    // passes are filling in what the first capsule could not reach, and by then
+    // the remaining protrusion is evenly spread by construction, so re-applying
+    // the test would reject every one of them and cap coverage at a single
+    // capsule. They still have to clear minGain and the vertex count.
+    const concentration = meanProtrusion > 1e-6 ? lobeSum / found / meanProtrusion : 0;
+    if (covered.length === 0 && concentration < opt.minConcentration)
+        return null;
+    const directionality = Math.sqrt(dirX * dirX + dirY * dirY + dirZ * dirZ) / found;
+    if (directionality < opt.minDirectionality)
+        return null;
+    // Quantile-clipped extent per axis.
+    const lo = [0, 0, 0];
+    const hi = [0, 0, 0];
+    const axis = new Array(found);
+    for (let a = 0; a < 3; a++) {
+        for (let i = 0; i < found; i++)
+            axis[i] = _local[i * 3 + a];
+        axis.sort((x, y) => x - y);
+        const k = Math.min(found - 1, Math.floor(found * opt.quantile));
+        lo[a] = axis[k];
+        hi[a] = axis[found - 1 - k];
+    }
+    const hx = (hi[0] - lo[0]) * 0.5;
+    const hy = (hi[1] - lo[1]) * 0.5;
+    const hz = (hi[2] - lo[2]) * 0.5;
+    if (hx <= 0 || hy <= 0 || hz <= 0)
+        return null;
+    const cx = (hi[0] + lo[0]) * 0.5;
+    const cy = (hi[1] + lo[1]) * 0.5;
+    const cz = (hi[2] + lo[2]) * 0.5;
+    // Fit a CAPSULE, not a box, and keep the source body's own orientation.
+    //
+    // A box fitted to a curved lobe puts its eight corners out in open air — on
+    // 托特's butt the worst corner measured 0.81 units from the nearest skin
+    // vertex, and cloth resting on that corner would float further off the body
+    // than the clipping it was added to fix. A capsule has no corners.
+    //
+    // Reusing the source rotation verbatim is what makes this cheap AND correct.
+    // PMX capsules are Y-aligned in their own frame, and a proxy's axis already
+    // runs along its limb — 下半身 is a transverse pill across the hips, which is
+    // exactly the way a butt lobe runs. Inheriting the rotation means no
+    // covariance fit and, more to the point, no quaternion→Euler conversion whose
+    // convention could disagree with the loader's.
+    // Radius from the lobe's own perpendicular spread, at a quantile — NOT from
+    // the enclosing half-extent.
+    //
+    // This is what decides whether the result looks right. A capsule inflates
+    // equally in every direction perpendicular to its axis, so sizing the radius
+    // to ENCLOSE the lobe makes a wide shallow patch into a fat capsule: it only
+    // needed to reach the butt's depth, but it also grew to the butt's width, and
+    // the surplus is surface standing off the skin everywhere else. Measured on
+    // 托特's pelvis that was 0.68 units of standoff, which reads as a skirt
+    // hovering in idle — trading a clipping artifact for a worse one.
+    //
+    // Taking a quantile of the actual distances puts the capsule's surface
+    // through the lobe rather than around it. The deepest points end up slightly
+    // outside it, which the next pass picks up.
+    const perp = new Array(found);
+    for (let i = 0; i < found; i++) {
+        const dx = _local[i * 3] - cx;
+        const dz = _local[i * 3 + 2] - cz;
+        perp[i] = Math.sqrt(dx * dx + dz * dz);
+    }
+    perp.sort((a, b) => a - b);
+    const fitRadius = perp[Math.min(found - 1, Math.floor(found * opt.radiusQuantile))];
+    if (fitRadius <= 0)
+        return null;
+    // size.y is the FULL cylinder length between cap centres, so the capsule
+    // spans h + 2r along the axis. Solve for the lobe's own extent.
+    const cyl = Math.max(0, hy * 2 - fitRadius * 2);
+    // Gain and overshoot at the capsule's six axis extremes: how far it reaches
+    // past the shape it supplements, and how far it sits from the surface it was
+    // fitted to. Overshoot is the number to watch if a result looks puffy.
+    let gain = 0;
+    let overshoot = 0;
+    const half = cyl * 0.5;
+    const probes = [
+        [cx + fitRadius, cy, cz], [cx - fitRadius, cy, cz],
+        [cx, cy + half + fitRadius, cz], [cx, cy - half - fitRadius, cz],
+        [cx, cy, cz + fitRadius], [cx, cy, cz - fitRadius],
+    ];
+    for (const [px, py, pz] of probes) {
+        const sd = coveredSignedDistance(rb, covered, px, py, pz);
+        if (sd > gain)
+            gain = sd;
+        // Only the part of the capsule that reaches OUTSIDE the original shape is
+        // new collision surface. A probe pointing inward has no skin vertex near it
+        // by construction — the lobe is a patch on the outside — and counting it
+        // would report overshoot for geometry that is buried in the character.
+        if (sd <= 0)
+            continue;
+        let nearest = Infinity;
+        for (let i = 0; i < found; i++) {
+            const dx = _local[i * 3] - px;
+            const dy = _local[i * 3 + 1] - py;
+            const dz = _local[i * 3 + 2] - pz;
+            const d2 = dx * dx + dy * dy + dz * dz;
+            if (d2 < nearest)
+                nearest = d2;
+        }
+        const d = Math.sqrt(nearest);
+        if (d > overshoot)
+            overshoot = d;
+    }
+    if (gain < opt.minGain)
+        return null;
+    // Back out to bind-pose world. Orientation is copied verbatim from the source
+    // rather than converted — the capsule is expressed in that frame, and
+    // re-deriving Euler angles would only introduce a convention to get wrong.
+    _v.x = cx;
+    _v.y = cy;
+    _v.z = cz;
+    Quat.rotateVecInto(q, _v, _r);
+    const wx = rb.shapePosition.x + _r.x;
+    const wy = rb.shapePosition.y + _r.y;
+    const wz = rb.shapePosition.z + _r.z;
+    const result = {
+        sourceIndex: index,
+        sourceName: rb.name,
+        vertexCount: owned.length,
+        protrudingCount: found,
+        maxProtrusion: deepest,
+        gain,
+        directionality,
+        concentration,
+        overshoot,
+        body: {
+            name: `${rb.name}__fit`,
+            englishName: `${rb.englishName}__fit`,
+            boneIndex: rb.boneIndex,
+            // Same group and mask as the body it supplements: it must be visible to
+            // exactly the cloth that was already meant to collide with this limb, and
+            // invisible to whatever the rigger excluded.
+            group: rb.group,
+            collisionMask: rb.collisionMask,
+            shape: RigidbodyShape.Capsule,
+            // PMX capsule semantics: size.x is the radius, size.y the FULL cylinder
+            // length between cap centres (Bullet halves it internally), size.z unused.
+            size: new Vec3(fitRadius, cyl, fitRadius),
+            shapePosition: new Vec3(wx, wy, wz),
+            shapeRotation: new Vec3(rb.shapeRotation.x, rb.shapeRotation.y, rb.shapeRotation.z),
+            // Static: it follows its bone and never integrates. Mass 0 keeps it out
+            // of the dynamic path entirely.
+            mass: 0,
+            linearDamping: 0,
+            angularDamping: 0,
+            restitution: rb.restitution,
+            friction: rb.friction,
+            type: RigidbodyType.Static,
+            bodyOffsetMatrixInverse: Mat4.identity(),
+        },
+    };
+    return { result, local: { cx, cy, cz, radius: fitRadius, cyl } };
+}
+/** Smallest characteristic dimension — the "how wide is this proxy" scale the
+ *  protrusion cap is judged against. */
+function shapeRadius(rb) {
+    switch (rb.shape) {
+        case RigidbodyShape.Sphere:
+            return rb.size.x;
+        case RigidbodyShape.Capsule:
+            return rb.size.x;
+        case RigidbodyShape.Box:
+            return Math.min(rb.size.x, rb.size.y, rb.size.z);
+        default:
+            return 0;
+    }
+}
+/** Signed distance to a Y-axis capsule centred at (cx,cy,cz), in the same
+ *  local frame. `cyl` is the full length between cap centres. */
+function capsuleSignedDistance(c, px, py, pz) {
+    const half = c.cyl * 0.5;
+    const dy = py - c.cy;
+    const t = dy > half ? half : dy < -half ? -half : dy;
+    const ax = px - c.cx;
+    const az = pz - c.cz;
+    const by = dy - t;
+    return Math.sqrt(ax * ax + by * by + az * az) - c.radius;
+}
+/** Distance to the UNION of the source shape and everything already fitted to
+ *  it. Union is a min over signed distances, so a later pass sees only what is
+ *  still exposed. */
+function coveredSignedDistance(rb, covered, px, py, pz) {
+    let best = localSignedDistance(rb, px, py, pz);
+    for (let i = 0; i < covered.length; i++) {
+        const d = capsuleSignedDistance(covered[i], px, py, pz);
+        if (d < best)
+            best = d;
+    }
+    return best;
+}
+/** Outward direction from whichever member of the union is nearest — the
+ *  gradient of coveredSignedDistance. */
+function coveredOutwardDir(rb, covered, px, py, pz, out) {
+    let best = localSignedDistance(rb, px, py, pz);
+    let nearest = -1;
+    for (let i = 0; i < covered.length; i++) {
+        const d = capsuleSignedDistance(covered[i], px, py, pz);
+        if (d < best) {
+            best = d;
+            nearest = i;
+        }
+    }
+    if (nearest < 0) {
+        localOutwardDir(rb, px, py, pz, out);
+        return;
+    }
+    // Same construction as localOutwardDir, for the winning capsule.
+    const c = covered[nearest];
+    const half = c.cyl * 0.5;
+    const dy = py - c.cy;
+    const t = dy > half ? half : dy < -half ? -half : dy;
+    const dx = px - c.cx;
+    const dz = pz - c.cz;
+    const by = dy - t;
+    const len = Math.sqrt(dx * dx + by * by + dz * dz);
+    if (len > 1e-9) {
+        out.x = dx / len;
+        out.y = by / len;
+        out.z = dz / len;
+    }
+    else {
+        out.x = 0;
+        out.y = 1;
+        out.z = 0;
+    }
+}
+/** Direction a body-local point escapes the shape in — the gradient of the
+ *  signed distance, i.e. the unit vector from its closest surface point. */
+function localOutwardDir(rb, px, py, pz, out) {
+    let dx, dy, dz;
+    switch (rb.shape) {
+        case RigidbodyShape.Capsule: {
+            const half = rb.size.y * 0.5;
+            const t = py > half ? half : py < -half ? -half : py;
+            dx = px;
+            dy = py - t;
+            dz = pz;
+            break;
+        }
+        case RigidbodyShape.Box: {
+            dx = px - Math.max(-rb.size.x, Math.min(rb.size.x, px));
+            dy = py - Math.max(-rb.size.y, Math.min(rb.size.y, py));
+            dz = pz - Math.max(-rb.size.z, Math.min(rb.size.z, pz));
+            break;
+        }
+        default: {
+            dx = px;
+            dy = py;
+            dz = pz;
+            break;
+        }
+    }
+    const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    if (len > 1e-9) {
+        out.x = dx / len;
+        out.y = dy / len;
+        out.z = dz / len;
+    }
+    else {
+        out.x = 0;
+        out.y = 1;
+        out.z = 0;
+    }
+}
+/** Signed distance from a body-local point to the shape's surface; > 0 outside. */
+function localSignedDistance(rb, px, py, pz) {
+    switch (rb.shape) {
+        case RigidbodyShape.Sphere:
+            return Math.sqrt(px * px + py * py + pz * pz) - rb.size.x;
+        case RigidbodyShape.Capsule: {
+            // PMX capsules are Y-aligned and size.y is the FULL cylinder length
+            // between cap centres, so the segment runs ±size.y/2.
+            const half = rb.size.y * 0.5;
+            const t = py > half ? half : py < -half ? -half : py;
+            const dy = py - t;
+            return Math.sqrt(px * px + dy * dy + pz * pz) - rb.size.x;
+        }
+        case RigidbodyShape.Box: {
+            // size is half-extents for boxes.
+            const qx = Math.abs(px) - rb.size.x;
+            const qy = Math.abs(py) - rb.size.y;
+            const qz = Math.abs(pz) - rb.size.z;
+            const ox = Math.max(qx, 0), oy = Math.max(qy, 0), oz = Math.max(qz, 0);
+            const outside = Math.sqrt(ox * ox + oy * oy + oz * oz);
+            return outside + Math.min(Math.max(qx, qy, qz), 0);
+        }
+        default:
+            return -Infinity;
+    }
+}
+// Rotation goes through Quat.rotateVecInto / rotateVecInvInto rather than
+// open-coded component formulas — this pass runs once at load, so there is
+// nothing to win by hand-rolling it and a sign error here would misplace every
+// fitted body.
+const _v = new Vec3(0, 0, 0);
+const _r = new Vec3(0, 0, 0);

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

@@ -1 +1 @@
-{"version":3,"file":"contact.d.ts","sourceRoot":"","sources":["../../src/physics/contact.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAa5C,eAAO,MAAM,cAAc,OAAO,CAAA;AAElC,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IAEb,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IAEX,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;IAEnB,oBAAoB,EAAE,MAAM,CAAA;IAC5B,uBAAuB,EAAE,MAAM,CAAA;IAC/B,uBAAuB,EAAE,MAAM,CAAA;IAI/B,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;IACxC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;IACxC,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IACjB;kFAC8E;IAC9E,GAAG,EAAE,MAAM,CAAA;IACX;6EACyE;IACzE,cAAc,EAAE,MAAM,CAAA;IACtB,gFAAgF;IAChF,kBAAkB,EAAE,MAAM,CAAA;IAC1B;;0DAEsD;IACtD,OAAO,EAAE,MAAM,CAAA;IAEf,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;IACrC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;IAC3C,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;IAC3C,QAAQ,EAAE,MAAM,CAAA;IAEhB,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;IACrC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;IAC3C,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;IAC3C,QAAQ,EAAE,MAAM,CAAA;CACjB;AAkCD,qBAAa,WAAW;IACtB,OAAO,CAAC,IAAI,CAAgB;IAC5B,KAAK,SAAI;IAET,OAAO,IAAI,OAAO;IAgBlB,KAAK,IAAI,IAAI;IAGb,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;CAGxB;AASD,wBAAgB,WAAW,CAAC,KAAK,EAAE,cAAc,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAahF;AAwoCD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,cAAc,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAgDrG;AAiCD,wBAAgB,YAAY,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAsB3E"}
+{"version":3,"file":"contact.d.ts","sourceRoot":"","sources":["../../src/physics/contact.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAa5C,eAAO,MAAM,cAAc,OAAO,CAAA;AAElC,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IAEb,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IAEX,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;IAEnB,oBAAoB,EAAE,MAAM,CAAA;IAC5B,uBAAuB,EAAE,MAAM,CAAA;IAC/B,uBAAuB,EAAE,MAAM,CAAA;IAI/B,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;IACxC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;IACxC,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IACjB;kFAC8E;IAC9E,GAAG,EAAE,MAAM,CAAA;IACX;6EACyE;IACzE,cAAc,EAAE,MAAM,CAAA;IACtB,gFAAgF;IAChF,kBAAkB,EAAE,MAAM,CAAA;IAC1B;;0DAEsD;IACtD,OAAO,EAAE,MAAM,CAAA;IAEf,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;IACrC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;IAC3C,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;IAC3C,QAAQ,EAAE,MAAM,CAAA;IAEhB,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;IACrC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;IAC3C,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;IAC3C,QAAQ,EAAE,MAAM,CAAA;CACjB;AAkCD,qBAAa,WAAW;IACtB,OAAO,CAAC,IAAI,CAAgB;IAC5B,KAAK,SAAI;IAET,OAAO,IAAI,OAAO;IAgBlB,KAAK,IAAI,IAAI;IAGb,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;CAGxB;AASD,wBAAgB,WAAW,CAAC,KAAK,EAAE,cAAc,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAahF;AAwoCD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,cAAc,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAgDrG;AAiCD,wBAAgB,YAAY,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAyB3E"}

package/dist/physics/contact.js

@@ -1091,7 +1091,10 @@ function flipOneNormal(c) {
 // see RigidBodyStore.getCollisionPairs. SAP / dynamic AABB tree pay off
 // above ~500 bodies; below that this flat sweep wins on cache locality.
 export function findContacts(store, pool) {
-    store.updateAabbs();
+    // Inflated by the contact margin and no more: a narrowphase only ever makes
+    // a contact within CONTACT_MARGIN, so a fatter box only bought SAT tests on
+    // pairs that could never touch — at 0.5 that was most of the collision cost.
+    store.updateAabbs(CONTACT_MARGIN + 0.01);
     const pairs = store.getCollisionPairs();
     for (let p = 0; p < pairs.length; p += 2) {
         const i = pairs[p];

package/dist/physics/physics.d.ts

@@ -14,6 +14,8 @@ export declare class RezePhysics {
     private timeAccum;
     private readonly fixedTimeStep;
     private readonly maxSubSteps;
+    private static readonly ITERATIONS;
+    private static readonly MIN_STEPS;
     /** EMA of one world.step's CPU cost; drives catch-up load shedding. */
     private stepCostEmaMs;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"physics.d.ts","sourceRoot":"","sources":["../../src/physics/physics.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"physics.d.ts","sourceRoot":"","sources":["../../src/physics/physics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAE/C,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,EAAS,KAAK,WAAW,EAAE,MAAM,SAAS,CAAA;AAYjD,qBAAa,WAAW;IACtB,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,KAAK,CAAO;IACpB,OAAO,CAAC,WAAW,CAA0B;IAC7C,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,UAAU,CAAO;IACzB,OAAO,CAAC,SAAS,CAAI;IAOrB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAU;IACxC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAK;IACjC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAI;IAGtC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAI;IACrC,uEAAuE;IACvE,OAAO,CAAC,aAAa,CAAM;IAC3B;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAM;IACzC;gFAC4E;IAC5E,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAI;IACpC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAK;IAMrC,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,gBAAgB,CAAc;IAQtC,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,eAAe,CAAc;IAMrC,OAAO,CAAC,OAAO,CAAY;IAE3B,OAAO,CAAC,aAAa,CAAY;IAMjC,OAAO,CAAC,WAAW,CAAY;IAG/B,aAAa,SAAI;IAEjB;yCACqC;IACrC,OAAO,CAAC,UAAU,CAAK;gBAEX,WAAW,EAAE,SAAS,EAAE,EAAE,MAAM,GAAE,KAAK,EAAO;IAoE1D,OAAO,CAAC,mBAAmB;IA4B3B,OAAO,CAAC,aAAa;IAKrB;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI;IAI3B,UAAU,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI;IAG/B,UAAU,IAAI,IAAI;IAGlB,2EAA2E;IAC3E,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,IAAI;IAGvC,OAAO,IAAI,WAAW,GAAG,IAAI;IAG7B,cAAc,IAAI,SAAS,EAAE;IAG7B,SAAS,IAAI,KAAK,EAAE;IAGpB,QAAQ,IAAI,cAAc;IAI1B,sBAAsB,IAAI,KAAK,CAAC;QAAE,QAAQ,EAAE,IAAI,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAA;KAAE,CAAC;IAiBnE,KAAK,CAAC,iBAAiB,EAAE,IAAI,EAAE,GAAG,IAAI;IActC,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE,IAAI,EAAE,EAAE,uBAAuB,EAAE,YAAY,GAAG,IAAI;IAiFxF,OAAO,CAAC,iBAAiB;IAuCzB,OAAO,CAAC,uBAAuB;IAqF/B,OAAO,CAAC,yBAAyB;IAgEjC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,sBAAsB;IA0C9B,OAAO,CAAC,2BAA2B;IA6EnC,OAAO,CAAC,wBAAwB;IA2BhC,OAAO,CAAC,sBAAsB;IAqC9B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAmB5D,6EAA6E;IAC7E,OAAO,CAAC,eAAe,CAA4B;IACnD,OAAO,CAAC,eAAe,CAA4B;IAEnD;;;;;;;;;OASG;IACH,qBAAqB,IAAI,MAAM,EAAE;IAUjC,OAAO,CAAC,oBAAoB;CA6D7B"}

package/dist/physics/physics.js

@@ -15,8 +15,14 @@ export class RezePhysics {
     constructor(rigidbodies, joints = []) {
         this.firstFrame = true;
         this.timeAccum = 0;
-        this.fixedTimeStep = 1 / 60;
-        this.maxSubSteps = 6;
+        // Two 120 Hz steps of 5 iterations where MMD takes one 60 Hz step of 10.
+        // Contacts and joints converge against each other far better in two small
+        // steps: a thin skirt lattice pressed on the legs shook 58% less and sat
+        // inside them a third as often. Collision runs every step — reusing one
+        // contact set across steps missed contacts that began between detections,
+        // and the late push-out shook worse than the single step ever did.
+        this.fixedTimeStep = 1 / 120;
+        this.maxSubSteps = 12;
         /** EMA of one world.step's CPU cost; drives catch-up load shedding. */
         this.stepCostEmaMs = 0.5;
         /**
@@ -90,6 +96,7 @@ export class RezePhysics {
         this.groundBody = gi;
         this.store.groundIndex = gi;
         this.world = new World(new Vec3(0, -98, 0));
+        this.world.solverIterations = RezePhysics.ITERATIONS;
         this.constraints = buildConstraints(rigidbodies, joints);
         this.solverCache = new SolverCache(this.constraints);
         this.contacts = new ContactPool();
@@ -258,7 +265,7 @@ export class RezePhysics {
         // Catching up must never cost more than a frame-budget slice: shed the backlog
         // instead (physics runs fractionally slow-motion for a beat; framerate holds).
         const budgetMs = Math.min(this.stepBudgetMaxMs, Math.max(this.stepBudgetMinMs, dt * 1000 * this.stepBudgetFraction));
-        const affordable = Math.max(1, Math.floor(budgetMs / Math.max(0.05, this.stepCostEmaMs)));
+        const affordable = Math.max(RezePhysics.MIN_STEPS, Math.floor(budgetMs / Math.max(0.05, this.stepCostEmaMs)));
         if (nSub > affordable)
             nSub = affordable;
         for (let k = 0; k < nSub; k++) {
@@ -817,3 +824,7 @@ export class RezePhysics {
         }
     }
 }
+RezePhysics.ITERATIONS = 5;
+// One 60 Hz frame of simulated time — what load shedding may never cut
+// below, the guarantee the single 1/60 step always gave.
+RezePhysics.MIN_STEPS = 2;

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

@@ -1 +1 @@
-{"version":3,"file":"solver.d.ts","sourceRoot":"","sources":["../../src/physics/solver.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAC5C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA;AAE1D,OAAO,KAAK,EAAW,WAAW,EAAE,MAAM,WAAW,CAAA;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAmJ/C,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,EACrB,WAAW,EAAE,sBAAsB,EAAE,EACrC,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,WAAW,EACrB,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,MAAM,EAClB,SAAS,GAAE,aAAa,GAAG,IAAW,GACrC,IAAI,CA+FN;AAgDD;8EAC8E;AAC9E,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,cAAc,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CA8B7E;AAyCD,qBAAa,WAAW;IACtB,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAA;IACxB,QAAQ,CAAC,CAAC,EAAE,UAAU,CAAA;IACtB;sEACkE;IAClE,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAA;gBACZ,WAAW,EAAE,sBAAsB,EAAE;CAUlD;AAs6BD,0EAA0E;AAC1E,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,cAAc,EACrB,QAAQ,EAAE,WAAW,EACrB,SAAS,EAAE,aAAa,GACvB,IAAI,CAcN"}
+{"version":3,"file":"solver.d.ts","sourceRoot":"","sources":["../../src/physics/solver.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAC5C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA;AAE1D,OAAO,KAAK,EAAW,WAAW,EAAE,MAAM,WAAW,CAAA;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AA6J/C,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,EACrB,WAAW,EAAE,sBAAsB,EAAE,EACrC,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,WAAW,EACrB,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,MAAM,EAClB,SAAS,GAAE,aAAa,GAAG,IAAW,GACrC,IAAI,CA+FN;AAgDD;8EAC8E;AAC9E,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,cAAc,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CA8B7E;AAyCD,qBAAa,WAAW;IACtB,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAA;IACxB,QAAQ,CAAC,CAAC,EAAE,UAAU,CAAA;IACtB;sEACkE;IAClE,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAA;gBACZ,WAAW,EAAE,sBAAsB,EAAE;CAUlD;AAs6BD,0EAA0E;AAC1E,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,cAAc,EACrB,QAAQ,EAAE,WAAW,EACrB,SAAS,EAAE,aAAa,GACvB,IAAI,CAcN"}

package/dist/physics/solver.js

@@ -30,7 +30,12 @@ const BOUNCE_THRESHOLD = 2.0;
 // pushes apart; separated (depth < 0, a speculative row) it ALLOWS approach at
 // the rate that closes the gap, which is what keeps those rows inert until the
 // body would really arrive.
-const CONTACT_ERP = 0.2;
+//
+// 0.1, half Bullet's 0.2: at 120 Hz each step closes a tenth of the overlap,
+// the same correction per second as MMD's 0.2 at 60 Hz, and a light cloth body
+// pressed between its joints and a collider stops being kicked out harder than
+// the joints can take back (skirt shake −20% on its own).
+const CONTACT_ERP = 0.1;
 // btContactSolverInfo's SOLVER_RANDMIZE_ORDER. Gauss-Seidel is order-biased —
 // rows solved first win — which on a cross-linked lattice shows up as a lean or
 // a period-2 chatter. Bullet ships the flag off; it is here to be measured.
@@ -104,6 +109,11 @@ const LIMIT_SOFTNESS_ANGULAR = 0.5;
 // ratio (ζ = 0.7); ported in isolation the motor form measured 0.0015 mean
 // reversal at jerk 0.5, the calmest joint-side result recorded.
 const SPRING_DAMPING = 1.0;
+// The motor's velocity gain at the rate PMX rigs are authored against — MMD's
+// Bullet at 60 Hz with 10 iterations. Bullet's form divides by the step's fps
+// and iteration count; at any other substep rate that retunes every spring,
+// so the gain is pinned here and the substep rate stays a solver choice.
+const SPRING_VEL_FACTOR = (60 * SPRING_DAMPING) / 10;
 // btConstraintInfo2::erp, from infoGlobal.m_erp — used only by getMotorFactor.
 const INFO_ERP = 0.2;
 // btTypedConstraint::getMotorFactor. Scales a motor down as it approaches the
@@ -532,7 +542,7 @@ function setupConstraint(con, ci, cache, store, dt, invDt, iterations) {
             const k = con.springStiffness[i];
             const serr = curr - con.equilibriumPoint[i];
             const force = serr * k;
-            const velFactor = (invDt * SPRING_DAMPING) / iterations;
+            const velFactor = SPRING_VEL_FACTOR;
             const target = -velFactor * force;
             // getMotorFactor's `vel` is Bullet's tag_vel: −targetVelocity for a
             // linear axis, which in our sign convention is the target itself.
@@ -635,7 +645,7 @@ function setupConstraint(con, ci, cache, store, dt, invDt, iterations) {
             const k = con.springStiffness[idx];
             const serr = _angDiffScratch[i] - con.equilibriumPoint[idx];
             const force = -serr * k;
-            const velFactor = (invDt * SPRING_DAMPING) / iterations;
+            const velFactor = SPRING_VEL_FACTOR;
             const target = -velFactor * force;
             // tag_vel for a rotational axis is Bullet's targetVelocity, i.e. −ours.
             const motFact = getMotorFactor(_angDiffScratch[i], con.angularMin[i], con.angularMax[i], -target, invDt * INFO_ERP);