reze-engine 0.25.2 → 0.27.0

package/src/shaders/passes/composite.ts

@@ -39,7 +39,7 @@ override APPLY_GAMMA: bool = true;
 @group(0) @binding(0) var hdrTex: texture_2d<f32>;
 @group(0) @binding(1) var bloomTex: texture_2d<f32>;   // bloomUpTexture mip 0 (full pyramid top)
 @group(0) @binding(2) var bloomSamp: sampler;
-@group(0) @binding(3) var<uniform> viewU: array<vec4<f32>, 7>;
+@group(0) @binding(3) var<uniform> viewU: array<vec4<f32>, 10>;
 // Aux mask/alpha texture. .r = bloom mask (unused here; bloom blit uses it).
 // .g = accumulated canvas alpha (what hdr.a carried before the HDR format
 // became rg11b10ufloat). We unpremultiply HDR by this alpha for tonemap, then
@@ -62,6 +62,8 @@ override APPLY_GAMMA: bool = true;
 // viewU[3] = (camera right, tanHalfFov·aspect); viewU[4] = (camera up, tanHalfFov);
 // viewU[5] = (camera forward, _) — refreshed per frame while skybox/effect active.
 // viewU[6] = (time seconds, effect on/off, canvas width, canvas height).
+// viewU[7] = (grade offset.rgb, contrast);  viewU[8] = (grade power.rgb, saturation);
+// viewU[9] = (grade slope.rgb, grade on/off) — see grade() below.
 // invGamma = 1/gamma precomputed on CPU — avoids a per-pixel divide.
 @group(0) @binding(6) var bgEquirect: texture_2d<f32>;
 
@@ -81,6 +83,24 @@ fn filmic(x: f32) -> f32 {
 
 /** Canvas size in pixels — for user background effects (aspect correction). */
 fn bgResolution() -> vec2f { return viewU[6].zw; }
+
+/** Color grading, applied to the tonemapped SCENE (not the background — see the
+ *  call site). The core is ASC CDL, the film-industry interchange standard:
+ *
+ *      out = (in · slope + offset) ^ power        then saturation  (SOP → SAT)
+ *
+ *  Using the real standard rather than invented controls means a look authored
+ *  here maps onto any grading tool. slope/offset/power are derived on the CPU
+ *  from the UI's shadow/midtone/highlight colors (see setColorGrading), so the
+ *  per-pixel cost is one mul-add, one pow, one lerp. */
+fn grade(c: vec3f) -> vec3f {
+  var x = pow(max(c * viewU[9].xyz + viewU[7].xyz, vec3f(0.0)), viewU[8].xyz);
+  // Contrast pivots on 0.5 — display-referred midpoint, since we grade post-Filmic.
+  x = (x - vec3f(0.5)) * viewU[7].w + vec3f(0.5);
+  // Rec.709 luma, matching the ASC SAT node.
+  let luma = dot(x, vec3f(0.2126, 0.7152, 0.0722));
+  return max(mix(vec3f(luma), x, viewU[8].w), vec3f(0.0));
+}
 `
 
 const COMPOSITE_BODY = /* wgsl */ `
@@ -107,6 +127,13 @@ const COMPOSITE_BODY = /* wgsl */ `
   let exposed = combined * exp2(viewU[0].x);
   let tm = vec3f(filmic(exposed.r), filmic(exposed.g), filmic(exposed.b));
   var disp = max(tm, vec3f(0.0));
+  // Grade the SCENE only, before the display gamma. Deliberately not applied to
+  // the background: it keeps a picked background color exactly as picked, and —
+  // load-bearing — leaves green-screen mode's key color unshifted so chroma
+  // keying still works. Skipped entirely when the grade is neutral.
+  if (viewU[9].w > 0.5) {
+    disp = grade(disp);
+  }
   if (APPLY_GAMMA) {
     disp = pow(disp, vec3f(viewU[0].y));
   }

package/src/vmd-loader.ts

@@ -32,6 +32,14 @@ export interface CameraKeyframe {
   interpolation: Uint8Array // 24 bytes
 }
 
+/** A VMD "IK/display" record: one moment at which chains are switched. */
+export interface IkFrame {
+  frame: number
+  /** Model visibility rides in the same record. Parsed, unused by playback. */
+  visible: boolean
+  states: { boneName: string; enabled: boolean }[]
+}
+
 export class VMDLoader {
   private view: DataView
   private offset = 0
@@ -100,6 +108,48 @@ export class VMDLoader {
     return frames
   }
 
+  static loadIkFromBuffer(buffer: ArrayBuffer): IkFrame[] {
+    return new VMDLoader(buffer).parseIk()
+  }
+
+  /**
+   * The IK/display block, at the very end of the file.
+   *
+   * MMD writes it after camera, light and self-shadow, and a motion-only VMD
+   * often stops before any of them — so every block is bounds-checked and a
+   * short file simply reports no IK data rather than throwing. Record sizes:
+   * bone 111 B, morph 23 B, camera 61 B, light 28 B, self-shadow 9 B.
+   */
+  private parseIk(): IkFrame[] {
+    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 end = this.view.buffer.byteLength
+    const seek = (size: number): boolean => {
+      if (this.offset + 4 > end) return false
+      this.skip(this.getUint32() * size)
+      return this.offset <= end
+    }
+    if (!seek(111) || !seek(23) || !seek(61) || !seek(28) || !seek(9)) return []
+    if (this.offset + 4 > end) return []
+
+    const count = this.getUint32()
+    const frames: IkFrame[] = []
+    for (let i = 0; i < count && this.offset + 9 <= end; i++) {
+      const frame = this.getUint32()
+      const visible = this.getUint8() !== 0
+      const ikCount = this.getUint32()
+      const states: { boneName: string; enabled: boolean }[] = []
+      for (let j = 0; j < ikCount && this.offset + 21 <= end; j++) {
+        states.push({ boneName: this.getShiftJisName(20), enabled: this.getUint8() !== 0 })
+      }
+      frames.push({ frame, visible, states })
+    }
+    frames.sort((a, b) => a.frame - b.frame)
+    return frames
+  }
+
   private parse(): VMDKeyFrame[] {
     // Read header (30 bytes)
     const header = this.getString(30)
@@ -315,6 +365,20 @@ export class VMDLoader {
     return v
   }
 
+  /** A fixed-width, NUL-padded Shift-JIS name — the form every VMD name takes. */
+  private getShiftJisName(len: number): string {
+    const bytes = new Uint8Array(this.view.buffer, this.offset, len)
+    this.offset += len
+    let end = bytes.indexOf(0)
+    if (end < 0) end = len
+    const slice = bytes.slice(0, end)
+    try {
+      return this.decoder.decode(slice)
+    } catch {
+      return String.fromCharCode(...slice)
+    }
+  }
+
   private getString(len: number): string {
     const bytes = new Uint8Array(this.view.buffer, this.offset, len)
     this.offset += len

package/src/vmd-writer.ts

@@ -7,6 +7,8 @@ const BONE_NAME_SIZE = 15
 const MORPH_NAME_SIZE = 15
 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
 
 // Build a Unicode-to-Shift-JIS lookup by inverting the TextDecoder mapping.
 let shiftJISTable: Map<string, number[]> | null = null
@@ -56,11 +58,30 @@ export class VMDWriter {
       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 key of keys) {
+        const at = ikByFrame.get(key.frame)
+        if (at) at.push({ boneName, enabled: key.enabled })
+        else ikByFrame.set(key.frame, [{ boneName, enabled: key.enabled }])
+      }
+    }
+    const ikFrames = [...ikByFrame.entries()].sort((a, b) => a[0] - b[0])
+    let ikSize = 0
+    for (const [, states] of ikFrames) ikSize += 4 + 1 + 4 + states.length * (IK_NAME_SIZE + 1)
+
     const size =
       HEADER_SIZE +
       MODEL_NAME_SIZE +
       4 + totalBoneFrames * BONE_FRAME_SIZE +
-      4 + totalMorphFrames * MORPH_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)
 
     const buffer = new ArrayBuffer(size)
     const view = new DataView(buffer)
@@ -124,6 +145,27 @@ export class VMDWriter {
       }
     }
 
+    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
+        view.setUint8(offset, 1) // model visible
+        offset += 1
+        view.setUint32(offset, states.length, true)
+        offset += 4
+        for (const state of states) {
+          offset = writeFixedShiftJIS(buffer, offset, state.boneName, IK_NAME_SIZE)
+          view.setUint8(offset, state.enabled ? 1 : 0)
+          offset += 1
+        }
+      }
+    }
+
     return buffer
   }
 }