reze-engine 0.50.4 → 0.50.6

package/dist/model.js

@@ -13,6 +13,10 @@ const _animSlerp = new Quat(0, 0, 0, 1);
 const _animInterpT = new Vec3(0, 0, 0);
 const _convOut = new Vec3(0, 0, 0);
 const _convMat = new Float32Array(16);
+// Scratch for the post-physics append recovery — see applyPhysicsAppend.
+const _appendBasisX = new Vec3(0, 0, 0);
+const _appendBasisY = new Vec3(0, 0, 0);
+const _appendBasisZ = new Vec3(0, 0, 0);
 // 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);
@@ -118,6 +122,15 @@ export class Model {
         this.rootMatrixValues = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
         this.rootMatrixDirty = false;
         this.rootIsIdentity = true;
+        /** 1 where the simulation overwrites the bone's world matrix. See setPhysicsDrivenBones. */
+        this.physicsDriven = null;
+        /** Bones to recompute after a step, in deform order — null when no rig needs it. */
+        this.physicsAppendOrder = null;
+        /** Simulated bones something inherits from; their local rotation is recovered. */
+        this.physicsAppendSources = null;
+        /** Recovered post-step local rotations, kept OUT of localRotations on purpose. */
+        this.appendRotOverride = null;
+        this.appendRotOverrideSet = null;
         this.tweenTimeMs = 0; // Time tracking for tweens (milliseconds)
         // Animation: state and multiple slots (idle, walk, attack, etc.); commit/rollback for action-game style
         this.animationState = new AnimationState();
@@ -1328,11 +1341,21 @@ export class Model {
         const t = (f - frames[i - 1]) / (frames[i] - frames[i - 1]);
         return values[i - 1] + (values[i] - values[i - 1]) * t;
     }
-    exportVmd(name) {
+    /**
+     * The clip called `name` as VMD bytes.
+     *
+     * `tracks` splits the file the same way `loadVmd`'s option splits what it
+     * reads: "motion" is the dance (bones + IK), "morphs" is the expression file
+     * to lay over one, "all" (the default) is both in one file as MMD exports it.
+     * A clip missing the half you asked for still writes — an empty motion or an
+     * empty expression file is a valid VMD, and is the honest answer to "export
+     * the morphs" for a clip that has none.
+     */
+    exportVmd(name, options) {
         const clip = this.animationState.getAnimationClip(name);
         if (!clip)
             throw new Error(`Animation clip "${name}" not found`);
-        return new VMDWriter().write(clip);
+        return new VMDWriter().write(clip, options);
     }
     play(name, options) {
         this.clipApplySuspended = false;
@@ -2175,7 +2198,139 @@ export class Model {
             worldMat.values.set(localMVals);
         }
     }
-    computeWorldMatrices() {
+    /**
+     * Which bones the physics simulation overwrites, and what that costs the
+     * append (付与) pass — the 胸 problem.
+     *
+     * PMX lets a bone inherit a fraction of another bone's rotation (付与親 /
+     * append parent). The pipeline computes that inheritance inside
+     * computeWorldMatrices, which runs BEFORE physics — and it reads the
+     * parent's LOCAL rotation, which physics never writes: the simulation
+     * publishes world matrices only. So when a rig hangs a bone off a simulated
+     * one, the inheritance saw the animated pose and nothing else, and the
+     * dependent bone sat still no matter how much the parent swung. Rigs that
+     * drive a chest this way — a simulated bone with the visible bones
+     * appending from it — produced no motion at all.
+     *
+     * The engine calls this once, after building the simulation, and it
+     * precomputes the whole answer: WHICH bones need revisiting after a step,
+     * in deform order. Everything downstream is a walk over that list.
+     */
+    setPhysicsDrivenBones(boneIndices) {
+        const bones = this.skeleton.bones;
+        const n = bones.length;
+        this.physicsDriven = new Uint8Array(n);
+        for (const b of boneIndices)
+            if (b >= 0 && b < n)
+                this.physicsDriven[b] = 1;
+        // Bones to recompute after a step: anything that INHERITS from a simulated
+        // bone, everything under it, and anything inheriting from those in turn.
+        // Simulated bones themselves are deliberately excluded — their world matrix
+        // IS the simulation's output, and recomputing it from a local pose the
+        // simulation never wrote would throw the step away.
+        const affected = new Uint8Array(n);
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (let k = 0; k < n; k++) {
+                const i = this.deformOrder[k];
+                if (affected[i] || this.physicsDriven[i])
+                    continue;
+                const b = bones[i];
+                const ap = b.appendParentIndex;
+                const inheritsAffected = (b.appendRotate || b.appendMove) && ap !== undefined && ap >= 0 && ap < n && (this.physicsDriven[ap] || affected[ap]);
+                const parentAffected = b.parentIndex >= 0 && affected[b.parentIndex];
+                if (inheritsAffected || parentAffected) {
+                    affected[i] = 1;
+                    changed = true;
+                }
+            }
+        }
+        const order = [];
+        for (let k = 0; k < n; k++) {
+            const i = this.deformOrder[k];
+            if (affected[i])
+                order.push(i);
+        }
+        this.physicsAppendOrder = order.length > 0 ? Int32Array.from(order) : null;
+        // The simulated bones something actually inherits from — the only ones
+        // whose post-step local rotation has to be recovered below.
+        const sources = new Set();
+        for (const i of order) {
+            const ap = bones[i].appendParentIndex;
+            if (ap !== undefined && ap >= 0 && ap < n && this.physicsDriven[ap])
+                sources.add(ap);
+        }
+        this.physicsAppendSources = sources.size > 0 ? Int32Array.from(sources) : null;
+        if (this.appendRotOverride === null && this.physicsAppendOrder) {
+            this.appendRotOverride = Array.from({ length: n }, () => Quat.identity());
+            this.appendRotOverrideSet = new Uint8Array(n);
+        }
+    }
+    /** The simulated bones that visible bones INHERIT from — the chest rig, in
+     *  one list. Empty unless setPhysicsDrivenBones found such a relationship. */
+    getAppendSourceBones() {
+        return this.physicsAppendSources ? Array.from(this.physicsAppendSources) : [];
+    }
+    /**
+     * Re-run the append pass against the simulation's result. Call after a step.
+     *
+     * Two halves. First the simulated bones an append parent list names get their
+     * post-step LOCAL rotation recovered — physics published only world matrices,
+     * and the append math speaks local. The recovery is the ordinary change of
+     * basis: local = parentWorld⁻¹ · world, read back as a quaternion off the
+     * relative basis, which is exact for the rigid transforms these are.
+     *
+     * Then the dependent bones recompute, in deform order, reading that recovered
+     * rotation instead of the animated one. The recovered value lives in its OWN
+     * array rather than in localRotations, deliberately: localRotations is what
+     * next frame's pose blends against and what the simulation reads to build
+     * kinematic targets, and writing a simulation result back into it would make
+     * the animation chase its own tail.
+     */
+    applyPhysicsAppend() {
+        const order = this.physicsAppendOrder;
+        const sources = this.physicsAppendSources;
+        if (!order || !sources || !this.appendRotOverride || !this.appendRotOverrideSet)
+            return;
+        const bones = this.skeleton.bones;
+        const worldMats = this.runtimeSkeleton.worldMatrices;
+        this.appendRotOverrideSet.fill(0);
+        for (let s = 0; s < sources.length; s++) {
+            const i = sources[s];
+            const w = worldMats[i].values;
+            const p = bones[i].parentIndex;
+            // Columns of the bone's own basis, expressed in its parent's frame. With
+            // no parent the world basis already IS the local one.
+            let bx0 = w[0], bx1 = w[1], bx2 = w[2];
+            let by0 = w[4], by1 = w[5], by2 = w[6];
+            let bz0 = w[8], bz1 = w[9], bz2 = w[10];
+            if (p >= 0) {
+                const pm = worldMats[p].values;
+                // parentᵀ · child, the rotation half of parentWorld⁻¹ · world: the
+                // parent basis is orthonormal, so its inverse is its transpose.
+                const r0 = bx0, r1 = bx1, r2 = bx2;
+                bx0 = pm[0] * r0 + pm[1] * r1 + pm[2] * r2;
+                bx1 = pm[4] * r0 + pm[5] * r1 + pm[6] * r2;
+                bx2 = pm[8] * r0 + pm[9] * r1 + pm[10] * r2;
+                const g0 = by0, g1 = by1, g2 = by2;
+                by0 = pm[0] * g0 + pm[1] * g1 + pm[2] * g2;
+                by1 = pm[4] * g0 + pm[5] * g1 + pm[6] * g2;
+                by2 = pm[8] * g0 + pm[9] * g1 + pm[10] * g2;
+                const b0 = bz0, b1 = bz1, b2 = bz2;
+                bz0 = pm[0] * b0 + pm[1] * b1 + pm[2] * b2;
+                bz1 = pm[4] * b0 + pm[5] * b1 + pm[6] * b2;
+                bz2 = pm[8] * b0 + pm[9] * b1 + pm[10] * b2;
+            }
+            _appendBasisX.setXYZ(bx0, bx1, bx2);
+            _appendBasisY.setXYZ(by0, by1, by2);
+            _appendBasisZ.setXYZ(bz0, bz1, bz2);
+            Quat.fromBasisInto(_appendBasisX, _appendBasisY, _appendBasisZ, this.appendRotOverride[i]);
+            this.appendRotOverrideSet[i] = 1;
+        }
+        this.computeWorldMatrices(order);
+    }
+    computeWorldMatrices(subset) {
         const bones = this.skeleton.bones;
         const localRot = this.runtimeSkeleton.localRotations;
         const localTrans = this.runtimeSkeleton.localTranslations;
@@ -2186,8 +2341,15 @@ export class Model {
         // Flat traversal in precomputed order: every bone's parent is already done, so no
         // per-bone visited check, no recursion, and no per-call allocation. Same per-bone
         // math as before. Scratch slots are safe to reuse since there's no reentrancy now.
-        const order = this.deformOrder;
-        for (let k = 0; k < boneCount; k++) {
+        //
+        // A SUBSET is the post-physics pass (applyPhysicsAppend): the same walk over
+        // the bones that inherit from a simulated one, in the same relative order,
+        // leaving every other bone — the simulated ones above all — untouched.
+        const order = subset ?? this.deformOrder;
+        const count = subset ? subset.length : boneCount;
+        const override = this.appendRotOverride;
+        const overrideSet = this.appendRotOverrideSet;
+        for (let k = 0; k < count; k++) {
             const i = order[k];
             const b = bones[i];
             const boneRot = localRot[i];
@@ -2200,7 +2362,11 @@ export class Model {
                 const hasRatio = Math.abs(ratio) > 1e-6;
                 if (hasRatio) {
                     if (b.appendRotate) {
-                        const appendRot = localRot[appendParentIdx];
+                        // The simulated parent's RECOVERED rotation when there is one — the
+                        // whole point of the post-physics pass. localRotations still holds
+                        // the animated pose for that bone, which is exactly what must not
+                        // be inherited here.
+                        const appendRot = override && overrideSet && overrideSet[appendParentIdx] ? override[appendParentIdx] : localRot[appendParentIdx];
                         let ax = appendRot.x, ay = appendRot.y, az = appendRot.z;
                         const aw = appendRot.w;
                         const absRatio = ratio < 0 ? -ratio : ratio;

package/dist/physics/physics.d.ts

@@ -92,6 +92,41 @@ export declare class RezePhysics {
     private carryDynamicThroughTeleport;
     private alignPinnedBodiesToBones;
     private restoreNonFiniteBodies;
+    /**
+     * Let the bodies carrying these bones swing longer, by damping them less.
+     *
+     * DAMPING, and not solver iterations, and the difference is the whole point.
+     * Under-converging a joint does make it swing further — it also stops it ever
+     * reaching equilibrium, so the body hangs visibly low at rest. Sag and swing
+     * come as a pair there and no amount of tuning separates them. Damping does
+     * separate them: for m·x″ + c·x′ + k·x = mg the rest position is mg/k, which
+     * c does not appear in. Less damping is a longer, larger oscillation about
+     * exactly the same resting height.
+     *
+     * Scoped to the bones asked for, because it is a look and not a correction —
+     * rigs whose visible bones inherit from a simulated one (付与親) are authored
+     * against an MMD that lets them move more than a faithfully damped
+     * simulation does. Hair and skirt keep their authored damping.
+     *
+     * `scale` multiplies the AUTHORED damping: 1 restores it, 0.5 halves it,
+     * 0 leaves the body undamped and ringing. Idempotent — the authored values
+     * are snapshotted on first use, so repeated calls set rather than compound.
+     */
+    setJiggleDamping(boneIndices: number[], scale: number): void;
+    /** Authored damping, kept so setJiggleDamping sets rather than compounds. */
+    private authoredLinDamp;
+    private authoredAngDamp;
+    /**
+     * Bones whose world matrix this simulation OVERWRITES each step.
+     *
+     * The same test applyDynamicsToBones runs — a Dynamic body bound to a real
+     * bone — exposed because the pose pipeline has to know. PMX lets a bone
+     * inherit rotation from an 付与親 (append parent), and when that parent is
+     * simulated the inheritance has to consume the SIMULATED result, not the
+     * animated pose the frame started with. Nothing else can answer which bones
+     * those are: the mapping lives in this store.
+     */
+    getPhysicsDrivenBones(): number[];
     private applyDynamicsToBones;
 }
 //# sourceMappingURL=physics.d.ts.map

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

@@ -1 +1 @@
-{"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;IACrB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAI;IAChC,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;gBAEL,WAAW,EAAE,SAAS,EAAE,EAAE,MAAM,GAAE,KAAK,EAAO;IA6D1D,OAAO,CAAC,mBAAmB;IA4B3B,OAAO,CAAC,aAAa;IAKrB,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,OAAO,CAAC,oBAAoB;CA6D7B"}
+{"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;IACrB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAI;IAChC,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;gBAEL,WAAW,EAAE,SAAS,EAAE,EAAE,MAAM,GAAE,KAAK,EAAO;IA6D1D,OAAO,CAAC,mBAAmB;IA4B3B,OAAO,CAAC,aAAa;IAKrB,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

@@ -44,6 +44,9 @@ export class RezePhysics {
         // Debug counter: frames on which a teleport (scrub/jump discontinuity)
         // was detected and settled.
         this.teleportCount = 0;
+        /** Authored damping, kept so setJiggleDamping sets rather than compounds. */
+        this.authoredLinDamp = null;
+        this.authoredAngDamp = null;
         this.rigidbodies = rigidbodies;
         this.joints = joints;
         // The floor is part of every world: a huge static box whose top face is
@@ -657,6 +660,67 @@ export class RezePhysics {
     //   boneWorld = bodyWorld × bodyOffsetInverse.
     // The body pose is the render-interpolated pose between the previous and current
     // substep states (alpha = fraction into the next step), which removes fixed-step judder.
+    /**
+     * Let the bodies carrying these bones swing longer, by damping them less.
+     *
+     * DAMPING, and not solver iterations, and the difference is the whole point.
+     * Under-converging a joint does make it swing further — it also stops it ever
+     * reaching equilibrium, so the body hangs visibly low at rest. Sag and swing
+     * come as a pair there and no amount of tuning separates them. Damping does
+     * separate them: for m·x″ + c·x′ + k·x = mg the rest position is mg/k, which
+     * c does not appear in. Less damping is a longer, larger oscillation about
+     * exactly the same resting height.
+     *
+     * Scoped to the bones asked for, because it is a look and not a correction —
+     * rigs whose visible bones inherit from a simulated one (付与親) are authored
+     * against an MMD that lets them move more than a faithfully damped
+     * simulation does. Hair and skirt keep their authored damping.
+     *
+     * `scale` multiplies the AUTHORED damping: 1 restores it, 0.5 halves it,
+     * 0 leaves the body undamped and ringing. Idempotent — the authored values
+     * are snapshotted on first use, so repeated calls set rather than compound.
+     */
+    setJiggleDamping(boneIndices, scale) {
+        const wanted = new Set(boneIndices.filter((b) => b >= 0));
+        if (wanted.size === 0)
+            return;
+        if (!this.authoredLinDamp || !this.authoredAngDamp) {
+            this.authoredLinDamp = Float32Array.from(this.store.linearDamping);
+            this.authoredAngDamp = Float32Array.from(this.store.angularDamping);
+        }
+        const s = Math.max(0, Math.min(1, scale));
+        const boneOf = this.store.boneIndex;
+        for (let i = 0; i < this.store.count; i++) {
+            const b = boneOf[i];
+            if (b < 0 || !wanted.has(b))
+                continue;
+            this.store.linearDamping[i] = this.authoredLinDamp[i] * s;
+            this.store.angularDamping[i] = this.authoredAngDamp[i] * s;
+        }
+        // The factors are cached against dt, which has not changed.
+        this.world.invalidateDampingCache();
+    }
+    /**
+     * Bones whose world matrix this simulation OVERWRITES each step.
+     *
+     * The same test applyDynamicsToBones runs — a Dynamic body bound to a real
+     * bone — exposed because the pose pipeline has to know. PMX lets a bone
+     * inherit rotation from an 付与親 (append parent), and when that parent is
+     * simulated the inheritance has to consume the SIMULATED result, not the
+     * animated pose the frame started with. Nothing else can answer which bones
+     * those are: the mapping lives in this store.
+     */
+    getPhysicsDrivenBones() {
+        const out = [];
+        for (let i = 0; i < this.store.count; i++) {
+            if (this.store.type[i] !== RigidbodyType.Dynamic)
+                continue;
+            const b = this.store.boneIndex[i];
+            if (b >= 0)
+                out.push(b);
+        }
+        return out;
+    }
     applyDynamicsToBones(boneWorldMatrices, alpha) {
         const N = this.store.count;
         const inv = this.store.bodyOffsetInverse;

package/dist/physics/world.d.ts

@@ -32,6 +32,10 @@ export declare class World {
     /** Per-pair contact impulse history behind warm starting. */
     private manifolds;
     private dampCacheDt;
+    /** Drop the cached damping factors. The cache is keyed on dt alone, because
+     *  authored damping never changed — until a rig asked for softer jiggle (see
+     *  RezePhysics.setJiggleDamping), which rewrites the store's values. */
+    invalidateDampingCache(): void;
     private linDampFactor;
     private angDampFactor;
     private windX;

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

@@ -1 +1 @@
-{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../src/physics/world.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAC9B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAE5C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA;AAC1D,OAAO,EAAgE,KAAK,WAAW,EAAE,MAAM,UAAU,CAAA;AAEzG,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,WAAW,CAAA;AAO1D;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW;IAC1B,iFAAiF;IACjF,SAAS,EAAE,IAAI,CAAA;IACf,8EAA8E;IAC9E,QAAQ,EAAE,MAAM,CAAA;IAChB;;;kEAG8D;IAC9D,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,wBAAwB;IACxB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,qBAAa,KAAK;IAChB,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAA;IACtB,gBAAgB,SAAK;IAErB,6DAA6D;IAC7D,OAAO,CAAC,SAAS,CAAsB;IAIvC,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,aAAa,CAA4B;IACjD,OAAO,CAAC,aAAa,CAA4B;IAIjD,OAAO,CAAC,KAAK,CAAI;IACjB,OAAO,CAAC,KAAK,CAAI;IACjB,OAAO,CAAC,KAAK,CAAI;IACjB,OAAO,CAAC,cAAc,CAAI;IAC1B,OAAO,CAAC,aAAa,CAAO;IAC5B;gDAC4C;IAC5C,OAAO,CAAC,SAAS,CAAI;gBAET,OAAO,EAAE,IAAI;IAIzB,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI;IAMzB,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,IAAI;IAoBvC,OAAO,IAAI,WAAW,GAAG,IAAI;IAW7B,IAAI,CACF,KAAK,EAAE,cAAc,EACrB,WAAW,EAAE,sBAAsB,EAAE,EACrC,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,WAAW,EACrB,EAAE,EAAE,MAAM,GACT,IAAI;CA4IR"}
+{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../src/physics/world.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAC9B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAE5C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA;AAC1D,OAAO,EAAgE,KAAK,WAAW,EAAE,MAAM,UAAU,CAAA;AAEzG,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,WAAW,CAAA;AAO1D;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW;IAC1B,iFAAiF;IACjF,SAAS,EAAE,IAAI,CAAA;IACf,8EAA8E;IAC9E,QAAQ,EAAE,MAAM,CAAA;IAChB;;;kEAG8D;IAC9D,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,wBAAwB;IACxB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,qBAAa,KAAK;IAChB,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAA;IACtB,gBAAgB,SAAK;IAErB,6DAA6D;IAC7D,OAAO,CAAC,SAAS,CAAsB;IAIvC,OAAO,CAAC,WAAW,CAAK;IAExB;;4EAEwE;IACxE,sBAAsB,IAAI,IAAI;IAG9B,OAAO,CAAC,aAAa,CAA4B;IACjD,OAAO,CAAC,aAAa,CAA4B;IAIjD,OAAO,CAAC,KAAK,CAAI;IACjB,OAAO,CAAC,KAAK,CAAI;IACjB,OAAO,CAAC,KAAK,CAAI;IACjB,OAAO,CAAC,cAAc,CAAI;IAC1B,OAAO,CAAC,aAAa,CAAO;IAC5B;gDAC4C;IAC5C,OAAO,CAAC,SAAS,CAAI;gBAET,OAAO,EAAE,IAAI;IAIzB,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI;IAMzB,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,IAAI;IAoBvC,OAAO,IAAI,WAAW,GAAG,IAAI;IAW7B,IAAI,CACF,KAAK,EAAE,cAAc,EACrB,WAAW,EAAE,sBAAsB,EAAE,EACrC,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,WAAW,EACrB,EAAE,EAAE,MAAM,GACT,IAAI;CA4IR"}

package/dist/physics/world.js

@@ -4,6 +4,12 @@ import { solveConstraints, saveContactImpulses, applySplitImpulsePush } from "./
 import { ManifoldCache } from "./manifold";
 import { findContacts } from "./contact";
 export class World {
+    /** Drop the cached damping factors. The cache is keyed on dt alone, because
+     *  authored damping never changed — until a rig asked for softer jiggle (see
+     *  RezePhysics.setJiggleDamping), which rewrites the store's values. */
+    invalidateDampingCache() {
+        this.dampCacheDt = -1;
+    }
     constructor(gravity) {
         this.solverIterations = 10;
         /** Per-pair contact impulse history behind warm starting. */

package/dist/vmd-loader.d.ts

@@ -25,8 +25,16 @@ export interface CameraKeyframe {
     target: Vec3;
     rotation: Vec3;
     fov: number;
-    interpolation: Uint8Array;
+    /** 24 bytes, contiguous per channel — see camera-animation.ts's `bez`.
+     *  Optional so a hand-authored keyframe does not have to know the layout;
+     *  both the sampler and the writer fall back to DEFAULT_CAMERA_INTERPOLATION.
+     *  A parsed file always carries its own. */
+    interpolation?: Uint8Array;
 }
+/** Linear in, linear out on all six channels. 20/107 is MMD's own linear pair
+ *  (its bezier bytes run 0-127), so a keyframe written with this reads back as
+ *  a straight line in MMD rather than an ease nobody asked for. */
+export declare const DEFAULT_CAMERA_INTERPOLATION: Uint8Array;
 /** A VMD "IK/display" record: one moment at which chains are switched. */
 export interface IkFrame {
     frame: number;

package/dist/vmd-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vmd-loader.d.ts","sourceRoot":"","sources":["../src/vmd-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAEnC,UAAU,SAAS;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,IAAI,CAAA;IACd,WAAW,EAAE,IAAI,CAAA;IACjB,aAAa,EAAE,UAAU,CAAA;CAC1B;AAED,UAAU,UAAU;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,SAAS,EAAE,CAAA;IACvB,WAAW,EAAE,UAAU,EAAE,CAAA;CAC1B;AAED;;qFAEqF;AACrF,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,IAAI,CAAA;IACZ,QAAQ,EAAE,IAAI,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;IACX,aAAa,EAAE,UAAU,CAAA;CAC1B;AAED,0EAA0E;AAC1E,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,CAAA;IACb,6EAA6E;IAC7E,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,EAAE,CAAA;CACjD;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,OAAO,CAAa;IAE5B,OAAO;WAWM,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAKtD,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,EAAE;IAKzD;mGAC+F;WAClF,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAK/D,MAAM,CAAC,oBAAoB,CAAC,MAAM,EAAE,WAAW,GAAG,cAAc,EAAE;IAOlE,OAAO,CAAC,WAAW;IA4BnB,MAAM,CAAC,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,EAAE;IAIvD;;;;;;;OAOG;IACH,OAAO,CAAC,OAAO;IA8Bf,OAAO,CAAC,KAAK;IAgGb,OAAO,CAAC,aAAa;IAuDrB,OAAO,CAAC,cAAc;IAqCtB,OAAO,CAAC,QAAQ;IAShB,OAAO,CAAC,SAAS;IASjB,OAAO,CAAC,UAAU;IASlB,gFAAgF;IAChF,OAAO,CAAC,eAAe;IAavB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,IAAI;CAMb"}
+{"version":3,"file":"vmd-loader.d.ts","sourceRoot":"","sources":["../src/vmd-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAEnC,UAAU,SAAS;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,IAAI,CAAA;IACd,WAAW,EAAE,IAAI,CAAA;IACjB,aAAa,EAAE,UAAU,CAAA;CAC1B;AAED,UAAU,UAAU;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,SAAS,EAAE,CAAA;IACvB,WAAW,EAAE,UAAU,EAAE,CAAA;CAC1B;AAED;;qFAEqF;AACrF,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,IAAI,CAAA;IACZ,QAAQ,EAAE,IAAI,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;IACX;;;gDAG4C;IAC5C,aAAa,CAAC,EAAE,UAAU,CAAA;CAC3B;AAED;;mEAEmE;AACnE,eAAO,MAAM,4BAA4B,EAAE,UAUvC,CAAA;AAEJ,0EAA0E;AAC1E,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,CAAA;IACb,6EAA6E;IAC7E,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,EAAE,CAAA;CACjD;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,OAAO,CAAa;IAE5B,OAAO;WAWM,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAKtD,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,EAAE;IAKzD;mGAC+F;WAClF,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAK/D,MAAM,CAAC,oBAAoB,CAAC,MAAM,EAAE,WAAW,GAAG,cAAc,EAAE;IAOlE,OAAO,CAAC,WAAW;IA4BnB,MAAM,CAAC,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,EAAE;IAIvD;;;;;;;OAOG;IACH,OAAO,CAAC,OAAO;IA8Bf,OAAO,CAAC,KAAK;IAgGb,OAAO,CAAC,aAAa;IAuDrB,OAAO,CAAC,cAAc;IAqCtB,OAAO,CAAC,QAAQ;IAShB,OAAO,CAAC,SAAS;IASjB,OAAO,CAAC,UAAU;IASlB,gFAAgF;IAChF,OAAO,CAAC,eAAe;IAavB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,IAAI;CAMb"}

package/dist/vmd-loader.js

@@ -1,4 +1,18 @@
 import { Quat, Vec3 } from "./math";
+/** Linear in, linear out on all six channels. 20/107 is MMD's own linear pair
+ *  (its bezier bytes run 0-127), so a keyframe written with this reads back as
+ *  a straight line in MMD rather than an ease nobody asked for. */
+export const DEFAULT_CAMERA_INTERPOLATION = (() => {
+    const ip = new Uint8Array(24);
+    for (let c = 0; c < 6; c++) {
+        const b = c * 4;
+        ip[b] = 20; // x1
+        ip[b + 1] = 107; // x2
+        ip[b + 2] = 20; // y1
+        ip[b + 3] = 107; // y2
+    }
+    return ip;
+})();
 export class VMDLoader {
     constructor(buffer) {
         this.offset = 0;

package/dist/vmd-writer.d.ts

@@ -1,5 +1,33 @@
 import { AnimationClip } from "./animation";
+import { type CameraKeyframe } from "./vmd-loader";
+/** Which half of a clip to write. Mirrors `Model.loadVmd`'s `tracks` option, so
+ *  a file this writer splits out is one the loader can read straight back:
+ *
+ *    "all"    bone + morph (+ IK) — one file, what MMD itself exports
+ *    "motion" bone (+ IK) only — the dance, no expressions
+ *    "morphs" morph only — an expression file (\u8868\u60c5\u30e2\u30fc\u30b7\u30e7\u30f3) to lay over a motion
+ *
+ *  IK rides with "motion" rather than "morphs" because it is bone state: which
+ *  chains solve says nothing about a face. */
+export type VmdTrackSelection = "all" | "motion" | "morphs";
 export declare class VMDWriter {
-    write(clip: AnimationClip): ArrayBuffer;
+    write(clip: AnimationClip, options?: {
+        tracks?: VmdTrackSelection;
+    }): ArrayBuffer;
+    /**
+     * A camera VMD: the shot's own file, with no model motion in it.
+     *
+     * Bone and morph counts are written as zero rather than omitted — the camera
+     * block sits after them in the format, so a reader walking the file in order
+     * (including this package's own parseCamera) has to pass through both to
+     * reach it. Light, self-shadow and IK blocks are left off entirely; every
+     * reader bounds-checks past the camera block, and MMD is happy with a file
+     * that simply ends there.
+     *
+     * `frames` is sorted by frame on the way out: CameraAnimation binary-searches
+     * the track it loads, and an out-of-order file would sample wrong rather than
+     * fail loudly.
+     */
+    writeCamera(frames: CameraKeyframe[]): ArrayBuffer;
 }
 //# sourceMappingURL=vmd-writer.d.ts.map

package/dist/vmd-writer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vmd-writer.d.ts","sourceRoot":"","sources":["../src/vmd-writer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAmC,MAAM,aAAa,CAAA;AAiD5E,qBAAa,SAAS;IACpB,KAAK,CAAC,IAAI,EAAE,aAAa,GAAG,WAAW;CAwHxC"}
+{"version":3,"file":"vmd-writer.d.ts","sourceRoot":"","sources":["../src/vmd-writer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAmC,MAAM,aAAa,CAAA;AAC5E,OAAO,EAAgC,KAAK,cAAc,EAAE,MAAM,cAAc,CAAA;AAsDhF;;;;;;;;8CAQ8C;AAC9C,MAAM,MAAM,iBAAiB,GAAG,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAA;AAE3D,qBAAa,SAAS;IACpB,KAAK,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,iBAAiB,CAAA;KAAE,GAAG,WAAW;IAiIjF;;;;;;;;;;;;;OAaG;IACH,WAAW,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG,WAAW;CA2CnD"}

package/dist/vmd-writer.js

@@ -1,3 +1,4 @@
+import { DEFAULT_CAMERA_INTERPOLATION } from "./vmd-loader";
 const VMD_HEADER = "Vocaloid Motion Data 0002";
 const HEADER_SIZE = 30;
 const MODEL_NAME_SIZE = 20;
@@ -7,6 +8,11 @@ const BONE_FRAME_SIZE = BONE_NAME_SIZE + 4 + 12 + 16 + 64; // 111 bytes
 const MORPH_FRAME_SIZE = MORPH_NAME_SIZE + 4 + 4; // 23 bytes
 /** IK bone names get 20 bytes in the IK block, not the 15 bones get elsewhere. */
 const IK_NAME_SIZE = 20;
+/** frame + distance + target(3) + rotation(3) + interpolation(24) + fov + perspective. */
+const CAMERA_FRAME_SIZE = 4 + 4 + 12 + 12 + 24 + 4 + 1; // 61 bytes
+/** What MMD stamps in the model-name field of a camera VMD. Tools sniff it to
+ *  tell a camera file from a motion at a glance, so write what they expect. */
+const CAMERA_MODEL_NAME = "\u30ab\u30e1\u30e9\u30fb\u7167\u660e";
 // Build a Unicode-to-Shift-JIS lookup by inverting the TextDecoder mapping.
 let shiftJISTable = null;
 function getShiftJISTable() {
@@ -47,20 +53,27 @@ function encodeShiftJIS(str) {
     return new Uint8Array(bytes);
 }
 export class VMDWriter {
-    write(clip) {
+    write(clip, options) {
+        const tracks = options?.tracks ?? "all";
+        const wantBones = tracks !== "morphs";
+        const wantMorphs = tracks !== "motion";
         let totalBoneFrames = 0;
-        for (const frames of clip.boneTracks.values()) {
-            totalBoneFrames += frames.length;
+        if (wantBones) {
+            for (const frames of clip.boneTracks.values()) {
+                totalBoneFrames += frames.length;
+            }
         }
         let totalMorphFrames = 0;
-        for (const frames of clip.morphTracks.values()) {
-            totalMorphFrames += frames.length;
+        if (wantMorphs) {
+            for (const frames of clip.morphTracks.values()) {
+                totalMorphFrames += frames.length;
+            }
         }
         // IK state is stored per MOMENT, not per bone: one record lists every chain
         // and its state at that frame. So the tracks are transposed back into the
         // frames they were flattened from.
         const ikByFrame = new Map();
-        for (const [boneName, keys] of clip.ikTracks ?? []) {
+        for (const [boneName, keys] of (wantBones ? clip.ikTracks : undefined) ?? []) {
             for (const key of keys) {
                 const at = ikByFrame.get(key.frame);
                 if (at)
@@ -92,7 +105,7 @@ export class VMDWriter {
         view.setUint32(offset, totalBoneFrames, true);
         offset += 4;
         // Bone frames
-        for (const frames of clip.boneTracks.values()) {
+        for (const frames of wantBones ? clip.boneTracks.values() : []) {
             for (const kf of frames) {
                 // Bone name (15 bytes, Shift-JIS)
                 offset = writeFixedShiftJIS(buffer, offset, kf.boneName, BONE_NAME_SIZE);
@@ -125,7 +138,7 @@ export class VMDWriter {
         view.setUint32(offset, totalMorphFrames, true);
         offset += 4;
         // Morph frames
-        for (const frames of clip.morphTracks.values()) {
+        for (const frames of wantMorphs ? clip.morphTracks.values() : []) {
             for (const kf of frames) {
                 // Morph name (15 bytes, Shift-JIS)
                 offset = writeFixedShiftJIS(buffer, offset, kf.morphName, MORPH_NAME_SIZE);
@@ -160,6 +173,69 @@ export class VMDWriter {
         }
         return buffer;
     }
+    /**
+     * A camera VMD: the shot's own file, with no model motion in it.
+     *
+     * Bone and morph counts are written as zero rather than omitted — the camera
+     * block sits after them in the format, so a reader walking the file in order
+     * (including this package's own parseCamera) has to pass through both to
+     * reach it. Light, self-shadow and IK blocks are left off entirely; every
+     * reader bounds-checks past the camera block, and MMD is happy with a file
+     * that simply ends there.
+     *
+     * `frames` is sorted by frame on the way out: CameraAnimation binary-searches
+     * the track it loads, and an out-of-order file would sample wrong rather than
+     * fail loudly.
+     */
+    writeCamera(frames) {
+        const sorted = [...frames].sort((a, b) => a.frame - b.frame);
+        const size = HEADER_SIZE + MODEL_NAME_SIZE + 4 + 4 + 4 + sorted.length * CAMERA_FRAME_SIZE;
+        const buffer = new ArrayBuffer(size);
+        const view = new DataView(buffer);
+        let offset = 0;
+        offset = writeFixedString(buffer, offset, VMD_HEADER, HEADER_SIZE);
+        offset = writeFixedShiftJIS(buffer, offset, CAMERA_MODEL_NAME, MODEL_NAME_SIZE);
+        view.setUint32(offset, 0, true); // bone frame count
+        offset += 4;
+        view.setUint32(offset, 0, true); // morph frame count
+        offset += 4;
+        view.setUint32(offset, sorted.length, true);
+        offset += 4;
+        for (const kf of sorted) {
+            view.setUint32(offset, kf.frame, true);
+            offset += 4;
+            view.setFloat32(offset, kf.distance, true);
+            offset += 4;
+            view.setFloat32(offset, kf.target.x, true);
+            offset += 4;
+            view.setFloat32(offset, kf.target.y, true);
+            offset += 4;
+            view.setFloat32(offset, kf.target.z, true);
+            offset += 4;
+            // Euler radians, as the loader reads them.
+            view.setFloat32(offset, kf.rotation.x, true);
+            offset += 4;
+            view.setFloat32(offset, kf.rotation.y, true);
+            offset += 4;
+            view.setFloat32(offset, kf.rotation.z, true);
+            offset += 4;
+            // 24 bytes, contiguous per channel — see camera-animation.ts's `bez`.
+            // Short or missing tables are padded with a linear default rather than
+            // writing junk: a hand-built keyframe should not have to know the layout.
+            const ip = new Uint8Array(24);
+            ip.set(DEFAULT_CAMERA_INTERPOLATION);
+            if (kf.interpolation)
+                ip.set(kf.interpolation.subarray(0, 24));
+            new Uint8Array(buffer, offset, 24).set(ip);
+            offset += 24;
+            // fov is degrees, and an integer in the file — MMD's own field is u32.
+            view.setUint32(offset, Math.max(0, Math.round(kf.fov)), true);
+            offset += 4;
+            view.setUint8(offset, 0); // 0 = perspective
+            offset += 1;
+        }
+        return buffer;
+    }
 }
 function writeFixedString(buffer, offset, str, maxBytes) {
     const bytes = new Uint8Array(buffer, offset, maxBytes);

package/package.json

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