reze-engine 0.21.1 → 0.22.0

package/src/math.ts

@@ -535,6 +535,23 @@ export class Mat4 {
     out[14] = pz
   }
 
+  // Position + rotation + UNIFORM scale. Scales the rotation basis (columns 0–2) by s;
+  // uniform scale keeps normals correct after the shader's normalize() (no inverse-transpose).
+  static fromPositionRotationScaleInto(
+    px: number, py: number, pz: number,
+    qx: number, qy: number, qz: number, qw: number,
+    s: number,
+    out: Float32Array
+  ): void {
+    Mat4.fromQuatInto(qx, qy, qz, qw, out, 0)
+    out[0] *= s; out[1] *= s; out[2] *= s
+    out[4] *= s; out[5] *= s; out[6] *= s
+    out[8] *= s; out[9] *= s; out[10] *= s
+    out[12] = px
+    out[13] = py
+    out[14] = pz
+  }
+
   // In-place 4x4 inverse into out array. Returns true on success, false if singular (out untouched).
   static inverseInto(m: Float32Array, out: Float32Array): boolean {
     const a00 = m[0], a01 = m[1], a02 = m[2], a03 = m[3]

package/src/model.ts

@@ -199,6 +199,17 @@ export class Model {
     return this._rotation
   }
 
+  /** Uniform scale (default 1). Used to fit a stage.pmx to the character. */
+  get scale(): number {
+    return this._scale
+  }
+
+  /** Whether this model renders. Hidden models skip the main, shadow, and pick passes;
+   *  physics keeps running so they resume consistently. */
+  get visible(): boolean {
+    return this._visible
+  }
+
   setPosition(position: Vec3): void {
     this._position.set(position)
     this.rootMatrixDirty = true
@@ -209,6 +220,15 @@ export class Model {
     this.rootMatrixDirty = true
   }
 
+  setScale(scale: number): void {
+    this._scale = scale
+    this.rootMatrixDirty = true
+  }
+
+  setVisible(visible: boolean): void {
+    this._visible = visible
+  }
+
   private vertexData: Float32Array<ArrayBuffer>
   private baseVertexData: Float32Array<ArrayBuffer> // Original vertex data before morphing
   private vertexCount: number
@@ -254,6 +274,8 @@ export class Model {
   // Skip-when-identity flag avoids the extra mat mul per bone when unused.
   private _position: Vec3 = Vec3.zeros()
   private _rotation: Quat = Quat.identity()
+  private _scale: number = 1
+  private _visible: boolean = true
   private rootMatrixValues: Float32Array = new Float32Array([1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1])
   private rootMatrixDirty: boolean = false
   private rootIsIdentity: boolean = true
@@ -851,11 +873,11 @@ export class Model {
 
     // Rebuild root matrix + cache identity-shortcut flag only when pos/rot changed.
     if (this.rootMatrixDirty) {
-      const p = this._position, r = this._rotation
-      Mat4.fromPositionRotationInto(p.x, p.y, p.z, r.x, r.y, r.z, r.w, this.rootMatrixValues)
+      const p = this._position, r = this._rotation, s = this._scale
+      Mat4.fromPositionRotationScaleInto(p.x, p.y, p.z, r.x, r.y, r.z, r.w, s, this.rootMatrixValues)
       this.rootIsIdentity =
         p.x === 0 && p.y === 0 && p.z === 0 &&
-        r.x === 0 && r.y === 0 && r.z === 0 && r.w === 1
+        r.x === 0 && r.y === 0 && r.z === 0 && r.w === 1 && s === 1
       this.rootMatrixDirty = false
     }
 

package/src/vmd-loader.ts

@@ -20,6 +20,18 @@ export interface VMDKeyFrame {
   morphFrames: MorphFrame[]
 }
 
+/** One MMD camera keyframe. The camera looks at `target` from `distance` away, oriented by
+ *  `rotation` (euler radians), with `fov` degrees. `interpolation` is 24 bytes: 6 channels
+ *  (posX, posY, posZ, rotation, distance, fov) × 4 bezier bytes (x1, x2, y1, y2). */
+export interface CameraKeyframe {
+  frame: number
+  distance: number
+  target: Vec3
+  rotation: Vec3 // euler radians
+  fov: number // degrees
+  interpolation: Uint8Array // 24 bytes
+}
+
 export class VMDLoader {
   private view: DataView
   private offset = 0
@@ -46,6 +58,48 @@ export class VMDLoader {
     return loader.parse()
   }
 
+  /** Parse only the camera track (a dedicated camera VMD, or the camera block of any VMD).
+   *  Returns [] if the file has no camera block (motion-only VMDs end after the morph block). */
+  static async loadCamera(url: string): Promise<CameraKeyframe[]> {
+    const loader = new VMDLoader(await fetch(url).then((r) => r.arrayBuffer()))
+    return loader.parseCamera()
+  }
+
+  static loadCameraFromBuffer(buffer: ArrayBuffer): CameraKeyframe[] {
+    return new VMDLoader(buffer).parseCamera()
+  }
+
+  // Seek past the bone + morph blocks (fixed record sizes) to the camera block, then read it.
+  // bone frame = 111 B (15 name + 4 frame + 12 pos + 16 rot + 64 interp); morph = 23 B
+  // (15 name + 4 frame + 4 weight); camera = 61 B.
+  private parseCamera(): CameraKeyframe[] {
+    this.offset = 0
+    const header = this.getString(30)
+    if (!header.startsWith("Vocaloid Motion Data")) throw new Error("Invalid VMD file header")
+    this.skip(20)
+    const boneCount = this.getUint32()
+    this.skip(boneCount * 111)
+    const morphCount = this.getUint32()
+    this.skip(morphCount * 23)
+    if (this.offset + 4 > this.view.buffer.byteLength) return [] // no camera block
+    const cameraCount = this.getUint32()
+
+    const frames: CameraKeyframe[] = []
+    for (let i = 0; i < cameraCount; i++) {
+      const frame = this.getUint32()
+      const distance = this.getFloat32()
+      const target = new Vec3(this.getFloat32(), this.getFloat32(), this.getFloat32())
+      const rotation = new Vec3(this.getFloat32(), this.getFloat32(), this.getFloat32())
+      const interpolation = new Uint8Array(24)
+      for (let j = 0; j < 24; j++) interpolation[j] = this.getUint8()
+      const fov = this.getUint32()
+      this.skip(1) // perspective flag (0 = perspective) — unused
+      frames.push({ frame, distance, target, rotation, fov, interpolation })
+    }
+    frames.sort((a, b) => a.frame - b.frame)
+    return frames
+  }
+
   private parse(): VMDKeyFrame[] {
     // Read header (30 bytes)
     const header = this.getString(30)