reze-engine 0.54.16 → 0.55.0

package/dist/shaders/passes/wireframe.js

@@ -0,0 +1,107 @@
+// The mesh itself, as lines, in the overlay layer.
+//
+// It skins here rather than reading the loader's CPU positions, and that is most
+// of why the pass exists. What is on screen is skinned and morphed on the GPU;
+// the CPU-side array is BIND POSE. Draw from that and the wireframe sits
+// perfectly on a T-posed model and slides off every animated one — which is
+// exactly the state a user is in while looking at weights.
+//
+// Each edge is expanded into a screen-space QUAD rather than drawn with line
+// topology. WebGPU pins a line to one device pixel, and one device pixel on a 2x
+// display is half a CSS pixel, which 4x MSAA then spreads across two of them:
+// the result is a grey suggestion of a wireframe rather than a wireframe. So the
+// draw is six vertices per edge, instanced, and the mesh is read through STORAGE
+// buffers — there is no per-vertex stream, because a quad's two corners come
+// from two different vertices of the model.
+//
+// The depth prepass shares this module's `vs` through its own entry point: it
+// draws the solid triangles with vertex buffers, writing depth only, so the
+// wireframe can be occluded by the body it belongs to.
+export const WIREFRAME_SHADER_WGSL = /* wgsl */ `
+struct CameraUniforms { view: mat4x4f, projection: mat4x4f, viewPos: vec3f, _pad: f32 };
+struct WireUniforms { color: vec4f, viewport: vec2f, thicknessPx: f32, _pad: f32 };
+
+@group(0) @binding(0) var<uniform> camera: CameraUniforms;
+@group(0) @binding(1) var<uniform> wire: WireUniforms;
+
+@group(1) @binding(0) var<storage, read> skinMats: array<mat4x4f>;
+// The model's own vertex buffer: pos(3), normal(3), uv(2) — 8 floats a vertex.
+@group(1) @binding(1) var<storage, read> vertices: array<f32>;
+// uint16x4 per vertex, so two u32 each.
+@group(1) @binding(2) var<storage, read> joints: array<u32>;
+// unorm8x4 per vertex, one u32 each.
+@group(1) @binding(3) var<storage, read> weights: array<u32>;
+// Pairs of vertex indices, one pair an edge.
+@group(1) @binding(4) var<storage, read> edges: array<u32>;
+
+fn skinnedPos(i: u32) -> vec3f {
+  let o = i * 8u;
+  let rest = vec4f(vertices[o], vertices[o + 1u], vertices[o + 2u], 1.0);
+
+  let j0 = joints[i * 2u];
+  let j1 = joints[i * 2u + 1u];
+  let packed = weights[i];
+  var w = vec4f(
+    f32(packed & 0xffu),
+    f32((packed >> 8u) & 0xffu),
+    f32((packed >> 16u) & 0xffu),
+    f32((packed >> 24u) & 0xffu),
+  ) / 255.0;
+  let sum = w.x + w.y + w.z + w.w;
+  w = select(vec4f(1.0, 0.0, 0.0, 0.0), w / max(sum, 1e-4), sum > 0.0001);
+
+  var acc = vec4f(0.0);
+  acc += (skinMats[j0 & 0xffffu] * rest) * w.x;
+  acc += (skinMats[j0 >> 16u] * rest) * w.y;
+  acc += (skinMats[j1 & 0xffffu] * rest) * w.z;
+  acc += (skinMats[j1 >> 16u] * rest) * w.w;
+  return acc.xyz;
+}
+
+// Six vertices an edge: (a,-1) (a,+1) (b,-1) (a,+1) (b,+1) (b,-1).
+@vertex fn vs(@builtin(vertex_index) vi: u32, @builtin(instance_index) ii: u32) -> @builtin(position) vec4f {
+  let a = edges[ii * 2u];
+  let b = edges[ii * 2u + 1u];
+  let vp = camera.projection * camera.view;
+  let ca = vp * vec4f(skinnedPos(a), 1.0);
+  let cb = vp * vec4f(skinnedPos(b), 1.0);
+
+  let atB = vi == 2u || vi == 4u || vi == 5u;
+  let side = select(-1.0, 1.0, vi == 1u || vi == 3u || vi == 4u);
+  let own = select(ca, cb, atB);
+  let other = select(cb, ca, atB);
+
+  let half = 0.5 * wire.viewport;
+  let s0 = (own.xy / max(abs(own.w), 1e-6)) * half;
+  let s1 = (other.xy / max(abs(other.w), 1e-6)) * half;
+  let d = s1 - s0;
+  // A degenerate edge has no direction on screen; any perpendicular will do,
+  // and it is a dot either way.
+  let tangent = select(vec2f(1.0, 0.0), normalize(d), length(d) > 1e-6);
+  let normalPx = vec2f(-tangent.y, tangent.x);
+  let offsetPx = normalPx * side * wire.thicknessPx * 0.5;
+  return vec4f(own.xy + (offsetPx / half) * own.w, own.z, own.w);
+}
+
+// The depth prepass: the solid mesh through the ordinary vertex stream, writing
+// depth and nothing else, so the far side of a body is hidden behind the near.
+@vertex fn vsDepth(
+  @location(0) position: vec3f,
+  @location(1) joints0: vec4<u32>,
+  @location(2) weights0: vec4<f32>,
+) -> @builtin(position) vec4f {
+  let rest = vec4f(position, 1.0);
+  let sum = weights0.x + weights0.y + weights0.z + weights0.w;
+  let w = select(vec4f(1.0, 0.0, 0.0, 0.0), weights0 / max(sum, 1e-4), sum > 0.0001);
+  var acc = vec4f(0.0);
+  for (var i = 0u; i < 4u; i++) {
+    acc += (skinMats[joints0[i]] * rest) * w[i];
+  }
+  return camera.projection * camera.view * vec4f(acc.xyz, 1.0);
+}
+
+@fragment fn fs() -> @location(0) vec4f {
+  // Premultiplied, like every other fragment in this layer.
+  return vec4f(wire.color.rgb * wire.color.a, wire.color.a);
+}
+`;

package/dist/shaders/score-api.d.ts

@@ -0,0 +1,10 @@
+/** Floats before the key map: count, pitch range, clock, duration, release. */
+export declare const SCORE_HEADER = 8;
+/** One energy slot per MIDI pitch. 128 is the MIDI range, not a cap we chose. */
+export declare const SCORE_KEYS = 128;
+/** Where the note records begin. */
+export declare const SCORE_NOTES: number;
+/** Floats per note: start, duration, pitch, velocity. */
+export declare const SCORE_STRIDE = 4;
+/** The rzNote*/ export declare function scoreApi(group: number, binding: number): string;
+//# sourceMappingURL=score-api.d.ts.map

package/dist/shaders/score-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"score-api.d.ts","sourceRoot":"","sources":["../../src/shaders/score-api.ts"],"names":[],"mappings":"AA8BA,+EAA+E;AAC/E,eAAO,MAAM,YAAY,IAAI,CAAA;AAC7B,iFAAiF;AACjF,eAAO,MAAM,UAAU,MAAM,CAAA;AAC7B,oCAAoC;AACpC,eAAO,MAAM,WAAW,QAA4B,CAAA;AACpD,yDAAyD;AACzD,eAAO,MAAM,YAAY,IAAI,CAAA;AAE7B,gBAAgB,CAChB,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CA2E/D"}

package/dist/shaders/score-api.js

@@ -0,0 +1,114 @@
+// The score data interface, as WGSL — shared verbatim by every effect module.
+//
+// The sibling of the audio interface, and precomputed for the same reason: an
+// export steps the engine frame by frame rather than playing in real time, so
+// anything read live from a player would render empty into the exported video.
+// A note list is inherently precomputed, so it cannot even be tempted.
+//
+// WHY THIS EXISTS BESIDE rzAudio* RATHER THAN INSTEAD OF IT. The audio interface
+// answers "how loud is the bass right now" — a spectrum, smeared across
+// frequency and time. That is the right shape for a reactive backdrop and the
+// wrong shape for a note: you cannot recover a discrete onset, a pitch and a
+// duration from band energy, and the crispness of a falling note is the whole
+// point of the look. The two are complementary — a scene can pulse its fog on
+// rzAudioOnset while its notes fall on rzNoteAge.
+//
+// LAYOUT. An 8-float header, then a 128-float live key map, then the notes at 4
+// floats each (start, duration, pitch, velocity). `time` and `playing` are
+// rewritten every frame by whoever owns playback, exactly as the audio header
+// is, so "now" is always the clock actually running.
+//
+// THE KEY MAP IS THE POINT OF THE DESIGN. Falling notes index the note list
+// directly — one particle per note, which is what makes the geometry trivial.
+// But a keyboard glow asks the opposite question, per pixel: is anything
+// sounding at THIS pitch? Answering that by scanning the note list would be
+// thousands of iterations per fragment. So the engine keeps a 128-entry
+// per-pitch energy map, updated once per frame on the CPU, and the glow becomes
+// one lookup — the same trade the audio interface makes by precomputing onset
+// so "a beat-triggered effect is one comparison instead of a per-pixel history
+// scan".
+/** Floats before the key map: count, pitch range, clock, duration, release. */
+export const SCORE_HEADER = 8;
+/** One energy slot per MIDI pitch. 128 is the MIDI range, not a cap we chose. */
+export const SCORE_KEYS = 128;
+/** Where the note records begin. */
+export const SCORE_NOTES = SCORE_HEADER + SCORE_KEYS;
+/** Floats per note: start, duration, pitch, velocity. */
+export const SCORE_STRIDE = 4;
+/** The rzNote*/ /* rzKey* accessors, with the buffer declared at the given binding. */
+export function scoreApi(group, binding) {
+    return /* wgsl */ `
+@group(${group}) @binding(${binding}) var<storage, read> _rzScore: array<f32>;
+
+/** Notes in the score; 0 when none is loaded, which every accessor below
+ *  tolerates by returning zero rather than reading past the end. */
+fn rzNoteCount() -> i32 { return i32(_rzScore[0]); }
+/** Where the score is NOW, in seconds — the clock every age below hangs from. */
+fn rzScoreTime() -> f32 { return _rzScore[3]; }
+/** 1 while the score is advancing, 0 paused or absent. */
+fn rzScorePlaying() -> f32 { return select(0.0, _rzScore[4], i32(_rzScore[0]) > 0); }
+/** Last note-off, in seconds — the length of the piece. */
+fn rzScoreDuration() -> f32 { return _rzScore[5]; }
+/** Lowest and highest pitch the score actually uses. Lay a keyboard out against
+ *  these rather than against 0..127 and a piano piece fills the screen instead
+ *  of occupying its middle third. */
+fn rzPitchLow() -> f32 { return _rzScore[1]; }
+fn rzPitchHigh() -> f32 { return _rzScore[2]; }
+
+fn _rzNoteAt(i: i32, field: i32) -> f32 {
+  if (i < 0 || i >= i32(_rzScore[0])) { return 0.0; }
+  return _rzScore[${SCORE_NOTES} + i * ${SCORE_STRIDE} + field];
+}
+
+/** When note i begins, in seconds. */
+fn rzNoteStart(i: i32) -> f32 { return _rzNoteAt(i, 0); }
+/** How long note i sounds, in seconds. */
+fn rzNoteLength(i: i32) -> f32 { return _rzNoteAt(i, 1); }
+/** MIDI pitch of note i — 60 is middle C. */
+fn rzNotePitch(i: i32) -> f32 { return _rzNoteAt(i, 2); }
+/** How hard note i was struck, 0..1. */
+fn rzNoteVelocity(i: i32) -> f32 { return _rzNoteAt(i, 3); }
+
+/**
+ * Seconds since note i began — NEGATIVE before it does.
+ *
+ * The falling-note function, and the sign is the whole of it: a note's height is
+ * -rzNoteAge(i) * speed, so a note not yet played sits above the keyboard at a
+ * distance proportional to how long is left, crosses zero exactly as it sounds,
+ * and keeps going. One expression, no state, no spawning — which is why one
+ * particle per note is the natural mapping and the pool index IS the note index.
+ */
+fn rzNoteAge(i: i32) -> f32 { return _rzScore[3] - rzNoteStart(i); }
+
+/** 1 while note i is sounding, 0 either side of it. */
+fn rzNoteHeld(i: i32) -> f32 {
+  let age = rzNoteAge(i);
+  return select(0.0, 1.0, age >= 0.0 && age < rzNoteLength(i));
+}
+
+/**
+ * Energy at a MIDI pitch right now: 1 the instant it is struck, holding while
+ * sounding, then falling away over the release set at install time.
+ *
+ * Per PITCH rather than per note, because that is the question a keyboard asks
+ * and a note list cannot answer cheaply — see the header. Fractional pitches
+ * read the nearest key, so a caller can hand this a continuous x across the
+ * keyboard without rounding first.
+ */
+fn rzKeyEnergy(pitch: f32) -> f32 {
+  let k = i32(round(pitch));
+  if (k < 0 || k >= ${SCORE_KEYS}) { return 0.0; }
+  return _rzScore[${SCORE_HEADER} + k];
+}
+
+/**
+ * A pitch's place across the score's own range, 0..1 — the x of a falling note
+ * and of the key it lands on, which have to agree or the effect is nonsense.
+ */
+fn rzPitchX(pitch: f32) -> f32 {
+  let lo = _rzScore[1];
+  let hi = _rzScore[2];
+  return select(0.5, (pitch - lo) / max(hi - lo, 1.0), hi > lo);
+}
+`;
+}

package/package.json

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