reze-engine 0.36.0 → 0.37.0

package/dist/model.js

@@ -16,10 +16,16 @@ const _convMat = new Float32Array(16);
 // Blend-path scratch: per-entry sample target and the crossfade's two fixed entries.
 const _blendQ = new Quat(0, 0, 0, 1);
 const _blendT = new Vec3(0, 0, 0);
+// Bone-morph scratch: the weighted rotation, slerped out of identity.
+const _boneMorphQ = new Quat(0, 0, 0, 1);
+const _boneMorphIdentity = new Quat(0, 0, 0, 1);
 const _fadeEntries = [
     { name: "", time: 0, weight: 0 },
     { name: "", time: 0, weight: 0 },
 ];
+/** PMX material-morph blend mode. Multiply lerps toward base*morph; add offsets from base. */
+export const MATERIAL_MORPH_MULTIPLY = 0;
+export const MATERIAL_MORPH_ADD = 1;
 export class Model {
     get name() {
         return this._name;
@@ -84,6 +90,23 @@ export class Model {
         // Non-fatal problems collected while parsing the PMX (see PmxLoader.warn).
         this.loadWarnings = [];
         this.morphsDirty = false; // Flag indicating if morphs need to be applied
+        // Bone morphs (type 2), flattened once at load so the per-frame pass is a
+        // straight walk with no allocation. Empty for models without them, which is
+        // most characters — a stage's doors and platforms are the common case.
+        this.boneMorphPlan = [];
+        // Bones any bone morph touches, plus their locals as they were BEFORE the last
+        // application. A pose source rewrites the locals it owns every frame, but a
+        // stage usually has no clip at all — nothing would reset these, and the offset
+        // would compound frame after frame into a slow drift.
+        this.boneMorphBones = [];
+        this.boneMorphRestoreR = [];
+        this.boneMorphRestoreT = [];
+        this.boneMorphApplied = false;
+        /** A full pose pass has run, so the world matrices are real. See isIdle. */
+        this.posedOnce = false;
+        // Set whenever effective weights change, for material/UV consumers that live
+        // outside this class. Vertex morphs use morphWeightsDirty (GPU) instead.
+        this.auxMorphDirty = true;
         // Root transform — model's placement in world space, independent of bones.
         // Folded into skin matrices (see getSkinMatrices) so every pass (main VS,
         // shadow VS, any future skinned pass) sees it without per-shader plumbing.
@@ -317,6 +340,122 @@ export class Model {
             }, {}),
             weights: new Float32Array(morphCount),
         };
+        const boneCount = this.skeleton.bones.length;
+        this.boneMorphPlan = [];
+        for (let i = 0; i < morphCount; i++) {
+            const morph = this.morphing.morphs[i];
+            if (morph.type !== 2 || !morph.boneOffsets)
+                continue;
+            for (const off of morph.boneOffsets) {
+                if (off.boneIndex < 0 || off.boneIndex >= boneCount)
+                    continue;
+                this.boneMorphPlan.push({
+                    morphIndex: i,
+                    boneIndex: off.boneIndex,
+                    translation: new Vec3(off.translation[0], off.translation[1], off.translation[2]),
+                    rotation: new Quat(off.rotation[0], off.rotation[1], off.rotation[2], off.rotation[3]),
+                });
+            }
+        }
+        const touched = new Set(this.boneMorphPlan.map((e) => e.boneIndex));
+        this.boneMorphBones = [...touched];
+        this.boneMorphRestoreR = this.boneMorphBones.map(() => Quat.identity());
+        this.boneMorphRestoreT = this.boneMorphBones.map(() => Vec3.zeros());
+        this.boneMorphApplied = false;
+    }
+    /**
+     * Bone morphs (type 2) compose over whatever the pose sources produced, the
+     * same way boneRotationOffsets do — they are an offset on the animated local
+     * transform, not a replacement for it. Re-applied every frame because each
+     * pose source rewrites the locals it touches.
+     *
+     * Stages are the reason this exists: a door or a lift is rigged as a bone
+     * morph and there is no VMD anywhere that drives it.
+     */
+    applyBoneMorphs() {
+        if (this.boneMorphPlan.length === 0)
+            return;
+        // Undo the previous application first. With a clip running this is a no-op
+        // in effect — the pose source already overwrote these bones — but a stage
+        // has no clip, so without it the same offset would be re-added every frame.
+        if (this.boneMorphApplied) {
+            for (let i = 0; i < this.boneMorphBones.length; i++) {
+                const b = this.boneMorphBones[i];
+                this.runtimeSkeleton.localRotations[b].set(this.boneMorphRestoreR[i]);
+                this.runtimeSkeleton.localTranslations[b].set(this.boneMorphRestoreT[i]);
+            }
+        }
+        for (let i = 0; i < this.boneMorphBones.length; i++) {
+            const b = this.boneMorphBones[i];
+            this.boneMorphRestoreR[i].set(this.runtimeSkeleton.localRotations[b]);
+            this.boneMorphRestoreT[i].set(this.runtimeSkeleton.localTranslations[b]);
+        }
+        this.boneMorphApplied = true;
+        const weights = this.getEffectiveMorphWeights();
+        for (const entry of this.boneMorphPlan) {
+            const w = weights[entry.morphIndex];
+            if (w < 0.0001)
+                continue;
+            const t = this.runtimeSkeleton.localTranslations[entry.boneIndex];
+            t.x += entry.translation.x * w;
+            t.y += entry.translation.y * w;
+            t.z += entry.translation.z * w;
+            // Scale the rotation by weight the way MMD does — slerp out of identity,
+            // then compose. Multiplying components would not stay a unit quaternion.
+            const r = this.runtimeSkeleton.localRotations[entry.boneIndex];
+            Quat.slerpInto(_boneMorphIdentity, entry.rotation, w, _boneMorphQ);
+            Quat.multiplyInto(r, _boneMorphQ, r);
+        }
+    }
+    /** True (once) when effective morph weights changed — the engine re-derives
+     *  material-morph uniforms from it. Separate from the GPU vertex path's flag
+     *  so both can consume the same change. */
+    consumeAuxMorphDirty() {
+        const d = this.auxMorphDirty;
+        this.auxMorphDirty = false;
+        return d;
+    }
+    /**
+     * Morph indices this model can actually act on, so a UI never offers a control
+     * that moves nothing.
+     *
+     * Driven directly: vertex (1), bone (2), material (8). Excluded: UV (3–7),
+     * which are parsed and kept but not yet applied; flip (9) and impulse (10),
+     * which are PMX 2.1 and would need the rigidbody solver.
+     *
+     * A group morph (0) is only as alive as what it points at — one referencing
+     * nothing but UV morphs is just as dead as the UV morphs themselves, so it is
+     * resolved rather than assumed.
+     */
+    getSupportedMorphIndices() {
+        const morphs = this.morphing.morphs;
+        const drivable = (t) => t === 1 || t === 2 || t === 8;
+        // Groups can reference groups, so walk with a seen-set rather than recursing.
+        const resolves = (start) => {
+            const seen = new Set();
+            const stack = [start];
+            while (stack.length > 0) {
+                const i = stack.pop();
+                if (seen.has(i) || i < 0 || i >= morphs.length)
+                    continue;
+                seen.add(i);
+                const m = morphs[i];
+                if (drivable(m.type))
+                    return true;
+                if (m.type === 0 && m.groupReferences) {
+                    for (const ref of m.groupReferences)
+                        stack.push(ref.morphIndex);
+                }
+            }
+            return false;
+        };
+        const out = [];
+        for (let i = 0; i < morphs.length; i++) {
+            const t = morphs[i].type;
+            if (drivable(t) || (t === 0 && resolves(i)))
+                out.push(i);
+        }
+        return out;
     }
     // Tween update - processes all tweens together with a single time reference
     // This avoids conflicts and ensures consistent timing across all tween types
@@ -676,6 +815,12 @@ export class Model {
             this.runtimeMorph.weights[idx] = clampedWeight;
             this.tweenState.morphActive[idx] = 0;
             this.applyMorphs();
+            // Vertex and material morphs are done by applyMorphs alone, but a bone
+            // morph lands in the pose pass — and a model with no clip (every stage)
+            // reports idle, so without this the pass never runs and the switch does
+            // nothing. Costs one redundant applyMorphs on the next frame.
+            if (this.boneMorphPlan.length > 0)
+                this.morphsDirty = true;
             try {
                 Engine.getInstance().markVertexBufferDirty(this);
             }
@@ -733,6 +878,10 @@ export class Model {
         for (let i = 0; i < morphCount; i++) {
             effectiveWeights[i] = Math.max(0, Math.min(1, effectiveWeights[i]));
         }
+        // Bone morphs read these every frame, but material/UV consumers live outside
+        // this class and need telling. Set on BOTH paths — a model whose only morphs
+        // are material morphs never enables the GPU vertex path at all.
+        this.auxMorphDirty = true;
         // GPU path: the compute pass applies the vertex offsets from these weights.
         if (this.gpuMorphEnabled) {
             this.morphWeightsDirty = true;
@@ -1557,6 +1706,45 @@ export class Model {
     // within that. A host driving bones directly — motion capture writing FK
     // rotations every frame with no clip playing — turns it off wholesale, because
     // there is no motion present to carry the per-chain answer.
+    /**
+     * Nothing can have moved this frame: no clip, no blend, no live tween, no
+     * morph weight change.
+     *
+     * Environment geometry is in this state almost every frame, so the engine
+     * skips the whole pose pass — sampling, world matrices, and the skin-matrix
+     * upload — for a stage that reports idle. A stage is usually the heaviest mesh
+     * in the scene and the one that never moves; paying a full pose pass for it
+     * every frame is the thing worth not doing.
+     */
+    isIdle() {
+        // Never idle before the first pose pass. The constructor leaves the world
+        // matrices identity, so skin = world × inverseBind collapses every vertex
+        // into bone-local space — the mesh piles up at the origin. A cast member is
+        // saved by running update() on frame 1 regardless; a stage that reported
+        // idle immediately would render as a heap and never recover.
+        if (!this.posedOnce)
+            return false;
+        return (!this.morphsDirty &&
+            this.oneShot === null &&
+            this.crossfade === null &&
+            (this.blendEntries === null || this.blendEntries.length === 0) &&
+            this.animationState.getCurrentClip() === null &&
+            !this.hasActiveTweens());
+    }
+    /** Any live rotation / translation / morph tween. */
+    hasActiveTweens() {
+        const s = this.tweenState;
+        for (let i = 0; i < s.rotActive.length; i++)
+            if (s.rotActive[i] === 1)
+                return true;
+        for (let i = 0; i < s.transActive.length; i++)
+            if (s.transActive[i] === 1)
+                return true;
+        for (let i = 0; i < s.morphActive.length; i++)
+            if (s.morphActive[i] === 1)
+                return true;
+        return false;
+    }
     update(deltaTime, ikEnabled = true) {
         // Update tween time (in milliseconds)
         this.tweenTimeMs += deltaTime * 1000;
@@ -1597,8 +1785,12 @@ export class Model {
             this.applyMorphs();
             this.morphsDirty = false;
         }
+        // After the pose sources and the constant offsets, before the world pass —
+        // bone morphs must survive into the world matrices IK then reads.
+        this.applyBoneMorphs();
         // Compute world matrices (needed for IK solving to read bone positions)
         this.computeWorldMatrices();
+        this.posedOnce = true;
         // Solve IK chains (modifies localRotations with final IK rotations). Chains
         // the clip switched off are skipped inside.
         if (ikEnabled) {

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"}