reze-engine 0.50.5 → 0.50.7

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)
@@ -77,10 +90,17 @@ export class VMDWriter {
             MODEL_NAME_SIZE +
             4 + totalBoneFrames * BONE_FRAME_SIZE +
             4 + totalMorphFrames * MORPH_FRAME_SIZE +
-            // Camera, light and self-shadow counts, then the IK block. Written only
-            // when there is IK state to carry: a plain motion stays byte-identical to
-            // what this writer produced before.
-            (ikFrames.length > 0 ? 4 * 4 + ikSize : 0);
+            // Camera, light, self-shadow and IK counts, ALWAYS — 16 bytes even when
+            // every one of them is zero.
+            //
+            // A VMD's sections are positional: a reader reaches each block by walking
+            // every count before it. Writing these only when there was IK state to
+            // carry left an ordinary motion ending right after the morph block, so
+            // anything looking for the sections that follow read past the end of the
+            // file and took whatever it found. MMD's own motion files carry all five
+            // counts unconditionally; so do ours now.
+            4 * 4 +
+            ikSize;
         const buffer = new ArrayBuffer(size);
         const view = new DataView(buffer);
         let offset = 0;
@@ -92,7 +112,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 +145,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);
@@ -137,13 +157,14 @@ export class VMDWriter {
                 offset += 4;
             }
         }
+        // Empty camera, light and self-shadow blocks, then the IK count — written
+        // whether or not there is IK state, so the file always ends on a complete
+        // section table.
+        for (let i = 0; i < 3; i++, offset += 4)
+            view.setUint32(offset, 0, true);
+        view.setUint32(offset, ikFrames.length, true);
+        offset += 4;
         if (ikFrames.length > 0) {
-            // Empty camera, light and self-shadow blocks — a reader walking the file
-            // in order has to pass through them to reach the IK block.
-            for (let i = 0; i < 3; i++, offset += 4)
-                view.setUint32(offset, 0, true);
-            view.setUint32(offset, ikFrames.length, true);
-            offset += 4;
             for (const [frame, states] of ikFrames) {
                 view.setUint32(offset, frame, true);
                 offset += 4;
@@ -160,6 +181,79 @@ export class VMDWriter {
         }
         return buffer;
     }
+    /**
+     * A camera VMD: the shot's own file, with no model motion in it.
+     *
+     * Every section count is written, including the empty ones. The format is
+     * positional, so a reader reaches each block by walking the counts before it —
+     * bone and morph to arrive at the camera block, and light, self-shadow and IK
+     * to leave it cleanly.
+     *
+     * The trailing three used to be omitted, on the theory that every reader
+     * bounds-checks past the camera block. They do not. This file type is
+     * カメラ・照明 — camera AND lighting — so MMD looks for the light block exactly
+     * where the file used to stop, read past the end, and lit the scene from
+     * whatever it found there. It reached users as a stray coloured light on a
+     * camera-only export.
+     *
+     * `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 + 4 * 3;
+        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;
+        }
+        // Light, self-shadow and IK/display counts. See the note above: the light
+        // block begins here, and leaving it off is what lit MMD from past the end
+        // of the file.
+        for (let i = 0; i < 3; i++, offset += 4)
+            view.setUint32(offset, 0, true);
+        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.5",
+  "version": "0.50.7",
   "description": "A lightweight WebGPU engine for real-time 3D MMD/PMX model rendering",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/camera-animation.ts

@@ -4,7 +4,7 @@
 
 import { Vec3 } from "./math"
 import { bezierInterpolate } from "./animation"
-import type { CameraKeyframe } from "./vmd-loader"
+import { DEFAULT_CAMERA_INTERPOLATION, type CameraKeyframe } from "./vmd-loader"
 
 const FPS = 30
 const DEG2RAD = Math.PI / 180
@@ -53,6 +53,19 @@ export class CameraAnimation {
     return this.frames.map((f) => f.frame)
   }
 
+  /**
+   * Every keyframe, in full — the track as an editable document.
+   *
+   * The counterpart to keyframeIndices(), which deliberately withholds the
+   * poses because a timeline only wants the rhythm. An EDITOR wants the poses:
+   * it has to show what the shot does at a cut, let it be changed, and write
+   * the result back out. Shallow copies, so a host mutating what it gets back
+   * cannot reach into the track this is sampling from mid-playback.
+   */
+  keyframes(): CameraKeyframe[] {
+    return this.frames.map((f) => ({ ...f }))
+  }
+
   /** Sample the camera pose at time `t` (seconds). Clamps to the track ends; null if empty. */
   sample(t: number): CameraPose | null {
     const frames = this.frames
@@ -76,7 +89,7 @@ export class CameraAnimation {
     const span = b.frame - a.frame
     const localT = span > 0 ? (frame - a.frame) / span : 0
     // The incoming interpolation curve is stored on the segment's end keyframe (b).
-    const ip = b.interpolation
+    const ip = b.interpolation ?? DEFAULT_CAMERA_INTERPOLATION
 
     return {
       target: new Vec3(

package/src/engine.ts

@@ -8,7 +8,8 @@ import { CULL_COMPUTE_WGSL } from "./shaders/passes/cull"
 import { buildAnchorTable, anchorAliasWgsl, EMPTY_ANCHOR_TABLE, type AnchorTable } from "./shaders/anchor-table"
 import { MIDI_HEADER, MIDI_KEYS, MIDI_NOTES, MIDI_STRIDE } from "./shaders/midi-api"
 import { decodeTga } from "./tga-loader"
-import { VMDLoader } from "./vmd-loader"
+import { VMDLoader, type CameraKeyframe } from "./vmd-loader"
+import { VMDWriter } from "./vmd-writer"
 import { CameraAnimation } from "./camera-animation"
 import { PmxLoader } from "./pmx-loader"
 import { RezePhysics } from "./physics"
@@ -6510,6 +6511,39 @@ export class Engine {
     this.camera.setVmdDriven(this.cameraAnimation !== null)
   }
 
+  /**
+   * Drive the shot from camera keyframes built in JS — the camera's answer to
+   * `Model.loadClip`.
+   *
+   * The two loadCameraVmd* methods take FILE BYTES, which is all a viewer ever
+   * needs. An editor needs the other direction: hold the track as data, change
+   * a keyframe, and see the result immediately. Going through the writer and
+   * back through the parser for every edit would work and would be absurd.
+   *
+   * Empty (or an empty array) clears the track and returns the camera to orbit,
+   * same as clearCameraVmd — a track with no keyframes cannot drive anything,
+   * and silently keeping the previous one would be worse than saying so.
+   */
+  loadCameraClip(frames: CameraKeyframe[]): void {
+    this.cameraAnimation = frames.length ? new CameraAnimation([...frames]) : null
+    this.camera.setVmdDriven(this.cameraAnimation !== null)
+  }
+
+  /** The loaded camera track as editable keyframes, or [] with none loaded.
+   *  Copies — mutating them does not reach the track being sampled. */
+  getCameraClip(): CameraKeyframe[] {
+    return this.cameraAnimation?.keyframes() ?? []
+  }
+
+  /** The loaded camera track as camera-VMD bytes. Throws with none loaded:
+   *  writing an empty camera file is a mistake worth hearing about, not a
+   *  30-byte header to hand someone as a download. */
+  exportCameraVmd(): ArrayBuffer {
+    const frames = this.cameraAnimation?.keyframes()
+    if (!frames?.length) throw new Error("No camera track loaded")
+    return new VMDWriter().writeCamera(frames)
+  }
+
   /** Turn the loaded camera VMD on/off (falls back to orbit when off). No-op if none loaded. */
   setCameraVmdEnabled(enabled: boolean): void {
     this.camera.setVmdDriven(enabled && this.cameraAnimation !== null)

package/src/index.ts

@@ -109,8 +109,8 @@ export {
   interpolateControlPoints,
   rawInterpolationToBoneInterpolation,
 } from "./animation"
-export { VMDLoader, type CameraKeyframe, type IkFrame } from "./vmd-loader"
-export { VMDWriter } from "./vmd-writer"
+export { VMDLoader, DEFAULT_CAMERA_INTERPOLATION, type CameraKeyframe, type IkFrame } from "./vmd-loader"
+export { VMDWriter, type VmdTrackSelection } from "./vmd-writer"
 export { PmxLoader } from "./pmx-loader"
 export { CameraAnimation, type CameraPose } from "./camera-animation"
 export { RezePhysics } from "./physics"

package/src/model.ts

@@ -4,7 +4,7 @@ import { joinAssetPath, type AssetReader } from "./asset-reader"
 import { Rigidbody, Joint } from "./physics"
 import { IKSolverSystem } from "./ik-solver"
 import { VMDLoader, type VMDKeyFrame } from "./vmd-loader"
-import { VMDWriter } from "./vmd-writer"
+import { VMDWriter, type VmdTrackSelection } from "./vmd-writer"
 import {
   AnimationClip,
   AnimationPlayOptions,
@@ -1720,10 +1720,20 @@ export class Model {
     return values[i - 1] + (values[i] - values[i - 1]) * t
   }
 
-  exportVmd(name: string): ArrayBuffer {
+  /**
+   * 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: string, options?: { tracks?: VmdTrackSelection }): ArrayBuffer {
     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(): void

package/src/vmd-loader.ts

@@ -29,9 +29,28 @@ export interface CameraKeyframe {
   target: Vec3
   rotation: Vec3 // euler radians
   fov: number // degrees
-  interpolation: Uint8Array // 24 bytes
+  /** 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 const DEFAULT_CAMERA_INTERPOLATION: Uint8Array = (() => {
+  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
+})()
+
 /** A VMD "IK/display" record: one moment at which chains are switched. */
 export interface IkFrame {
   frame: number

package/src/vmd-writer.ts

@@ -1,4 +1,5 @@
 import { AnimationClip, BoneInterpolation, ControlPoint } from "./animation"
+import { DEFAULT_CAMERA_INTERPOLATION, type CameraKeyframe } from "./vmd-loader"
 
 const VMD_HEADER = "Vocaloid Motion Data 0002"
 const HEADER_SIZE = 30
@@ -9,6 +10,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: Map<string, number[]> | null = null
@@ -47,22 +53,41 @@ function encodeShiftJIS(str: string): Uint8Array {
   return new Uint8Array(bytes)
 }
 
+/** 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 class VMDWriter {
-  write(clip: AnimationClip): ArrayBuffer {
+  write(clip: AnimationClip, options?: { tracks?: VmdTrackSelection }): ArrayBuffer {
+    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<number, { boneName: string; enabled: boolean }[]>()
-    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) at.push({ boneName, enabled: key.enabled })
@@ -78,10 +103,17 @@ export class VMDWriter {
       MODEL_NAME_SIZE +
       4 + totalBoneFrames * BONE_FRAME_SIZE +
       4 + totalMorphFrames * MORPH_FRAME_SIZE +
-      // Camera, light and self-shadow counts, then the IK block. Written only
-      // when there is IK state to carry: a plain motion stays byte-identical to
-      // what this writer produced before.
-      (ikFrames.length > 0 ? 4 * 4 + ikSize : 0)
+      // Camera, light, self-shadow and IK counts, ALWAYS — 16 bytes even when
+      // every one of them is zero.
+      //
+      // A VMD's sections are positional: a reader reaches each block by walking
+      // every count before it. Writing these only when there was IK state to
+      // carry left an ordinary motion ending right after the morph block, so
+      // anything looking for the sections that follow read past the end of the
+      // file and took whatever it found. MMD's own motion files carry all five
+      // counts unconditionally; so do ours now.
+      4 * 4 +
+      ikSize
 
     const buffer = new ArrayBuffer(size)
     const view = new DataView(buffer)
@@ -98,7 +130,7 @@ export class VMDWriter {
     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)
@@ -130,7 +162,7 @@ export class VMDWriter {
     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)
@@ -145,12 +177,14 @@ export class VMDWriter {
       }
     }
 
+    // Empty camera, light and self-shadow blocks, then the IK count — written
+    // whether or not there is IK state, so the file always ends on a complete
+    // section table.
+    for (let i = 0; i < 3; i++, offset += 4) view.setUint32(offset, 0, true)
+    view.setUint32(offset, ikFrames.length, true)
+    offset += 4
+
     if (ikFrames.length > 0) {
-      // Empty camera, light and self-shadow blocks — a reader walking the file
-      // in order has to pass through them to reach the IK block.
-      for (let i = 0; i < 3; i++, offset += 4) view.setUint32(offset, 0, true)
-      view.setUint32(offset, ikFrames.length, true)
-      offset += 4
       for (const [frame, states] of ikFrames) {
         view.setUint32(offset, frame, true)
         offset += 4
@@ -168,8 +202,78 @@ export class VMDWriter {
 
     return buffer
   }
+
+  /**
+   * A camera VMD: the shot's own file, with no model motion in it.
+   *
+   * Every section count is written, including the empty ones. The format is
+   * positional, so a reader reaches each block by walking the counts before it —
+   * bone and morph to arrive at the camera block, and light, self-shadow and IK
+   * to leave it cleanly.
+   *
+   * The trailing three used to be omitted, on the theory that every reader
+   * bounds-checks past the camera block. They do not. This file type is
+   * カメラ・照明 — camera AND lighting — so MMD looks for the light block exactly
+   * where the file used to stop, read past the end, and lit the scene from
+   * whatever it found there. It reached users as a stray coloured light on a
+   * camera-only export.
+   *
+   * `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 {
+    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 + 4 * 3
+    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
+    }
+
+    // Light, self-shadow and IK/display counts. See the note above: the light
+    // block begins here, and leaving it off is what lit MMD from past the end
+    // of the file.
+    for (let i = 0; i < 3; i++, offset += 4) view.setUint32(offset, 0, true)
+
+    return buffer
+  }
 }
 
+
 function writeFixedString(buffer: ArrayBuffer, offset: number, str: string, maxBytes: number): number {
   const bytes = new Uint8Array(buffer, offset, maxBytes)
   bytes.fill(0)