reze-engine 0.50.2 → 0.50.3

package/dist/shaders/passes/ground-noise.js

@@ -1,88 +0,0 @@
-// Bakes the ground's frosted micro-texture into a seamless, mipmapped tile.
-//
-// The shader used to evaluate four octaves of value noise per pixel — sixteen
-// hash rounds — and the ground covers the entire screen as soon as the camera
-// tilts toward the horizon. This produces the same character of pattern once, at
-// load, so the fragment shader pays one filtered fetch instead.
-//
-// SEAMLESS BY CONSTRUCTION. The original hash was not periodic, so a finite
-// crop of it could never tile. Here every octave's lattice wraps at a whole
-// number of cells across the tile, which makes the result repeat exactly at the
-// edges. The pattern is therefore not pixel-identical to the analytic version —
-// it is the same kind of noise, not the same noise. At the default strength of
-// 0.05 it modulates brightness by ±2.5%, where the repeat is not findable by eye.
-import { GROUND_NOISE_RES, GROUND_NOISE_TILE_WORLD } from "./ground";
-/** Lattice cells across the tile at octave 0. The analytic version sampled fbm
- *  at worldXZ × 3, so a tile spanning 8 world units covers 24 base cells — the
- *  same spatial frequency the surface had before. */
-const BASE_CELLS = GROUND_NOISE_TILE_WORLD * 3;
-const OCTAVES = 4;
-/** Deterministic lattice hash. Integer coordinates are wrapped by the caller,
- *  which is what makes the tile seamless. */
-function hash(ix, iy) {
-    let h = Math.imul(ix, 374761393) + Math.imul(iy, 668265263);
-    h = Math.imul(h ^ (h >>> 13), 1274126177);
-    return ((h ^ (h >>> 16)) >>> 0) / 4294967296;
-}
-/** Value noise on a lattice that repeats every `period` cells. */
-function periodicValueNoise(x, y, period) {
-    const ix = Math.floor(x);
-    const iy = Math.floor(y);
-    const fx = x - ix;
-    const fy = y - iy;
-    // Smoothstep weights — same curve the WGSL used.
-    const ux = fx * fx * (3 - 2 * fx);
-    const uy = fy * fy * (3 - 2 * fy);
-    const x0 = ((ix % period) + period) % period;
-    const y0 = ((iy % period) + period) % period;
-    const x1 = (x0 + 1) % period;
-    const y1 = (y0 + 1) % period;
-    const a = hash(x0, y0);
-    const b = hash(x1, y0);
-    const c = hash(x0, y1);
-    const d = hash(x1, y1);
-    return (a + (b - a) * ux) * (1 - uy) + (c + (d - c) * ux) * uy;
-}
-/**
- * The tile as 8-bit luminance, plus its mip chain (box-filtered, which is exact
- * for a repeating texture). Mips are the point as much as the speed: procedural
- * noise has no mip chain, so at grazing angles it shimmered.
- */
-export function buildGroundNoiseMips() {
-    const levels = [];
-    const res = GROUND_NOISE_RES;
-    const base = new Uint8Array(res * res);
-    for (let py = 0; py < res; py++) {
-        for (let px = 0; px < res; px++) {
-            // Texel centre, in units of octave-0 lattice cells.
-            const x = ((px + 0.5) / res) * BASE_CELLS;
-            const y = ((py + 0.5) / res) * BASE_CELLS;
-            let v = 0;
-            let amp = 0.5;
-            let freq = 1;
-            for (let o = 0; o < OCTAVES; o++) {
-                v += amp * periodicValueNoise(x * freq, y * freq, BASE_CELLS * freq);
-                freq *= 2;
-                amp *= 0.5;
-            }
-            base[py * res + px] = Math.max(0, Math.min(255, Math.round(v * 255)));
-        }
-    }
-    levels.push(base);
-    let src = base;
-    let size = res;
-    while (size > 1) {
-        const half = size >> 1;
-        const dst = new Uint8Array(half * half);
-        for (let y = 0; y < half; y++) {
-            for (let x = 0; x < half; x++) {
-                const s = y * 2 * size + x * 2;
-                dst[y * half + x] = (src[s] + src[s + 1] + src[s + size] + src[s + size + 1] + 2) >> 2;
-            }
-        }
-        levels.push(dst);
-        src = dst;
-        size = half;
-    }
-    return levels;
-}

package/dist/shaders/passes/sim.d.ts

@@ -1,34 +0,0 @@
-import { type CastLayout } from "./particles";
-export declare const SIM_MAX = 1024;
-/** rgba16float, ping-ponged. Two of these is the whole memory cost. */
-export declare const SIM_FORMAT: GPUTextureFormat;
-/** `// @sim 256` — the grid's resolution, in texels per side. */
-export declare function parseSimSize(wgsl: string, max: number): number;
-/** Whether this effect drives a grid at all. */
-export declare function simEntryPoint(wgsl: string): boolean;
-/**
- * `rzSim(uv)`, for a shader that READS the grid rather than steps it.
- *
- * Always compiled in, even for an effect with no grid — it then samples a 1×1
- * of zeroes. An accessor that exists only sometimes is one an author has to
- * guard, and a missing function is a compile error rather than a blank result.
- */
-export declare function simReadApi(group: number, tex: number, samp: number, size: number): string;
-/** `rzTime`/`rzDt`, for a module that has no clock of its own — the field pass.
- *  Same reason as above: a spliced simStep refers to them. */
-export declare function simClockApi(timeExpr: string): string;
-/**
- * The step shader: one invocation per texel, once per frame.
- *
- * The previous grid is bound as a SAMPLED texture and the next as a storage
- * texture, which is what makes the two different resources and the whole thing
- * legal — a shader cannot read and write one texture coherently, and the
- * ping-pong is not an optimisation but the only correct way to do this.
- *
- * Sampled rather than only fetched, because advection needs to read BETWEEN
- * texels: a semi-Lagrangian step asks "what was at the place this parcel came
- * from", and that place is almost never a texel centre. Point-sampling it is
- * what turns smoke into a staircase.
- */
-export declare function buildSimShader(wgsl: string, size: number, _cast: CastLayout): string;
-//# sourceMappingURL=sim.d.ts.map

package/dist/shaders/passes/sim.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sim.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/sim.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAA;AAgC7C,eAAO,MAAM,OAAO,OAAO,CAAA;AAC3B,uEAAuE;AACvE,eAAO,MAAM,UAAU,EAAE,gBAAgC,CAAA;AAEzD,iEAAiE;AACjE,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAM9D;AAED,gDAAgD;AAChD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CA6BzF;AAED;8DAC8D;AAC9D,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKpD;AAWD;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM,CAwDpF"}

package/dist/shaders/passes/sim.js

@@ -1,169 +0,0 @@
-import { audioApi } from "../audio-api";
-import { scoreApi } from "../score-api";
-import { EFFECT_SCENE_API } from "./composite";
-// A persistent grid an effect can step and read: the one thing an effect could
-// not have before, which is MEMORY.
-//
-// Every other mount is a pure function of position and time. A field shader
-// recomputes its noise from scratch every frame; a trail reads history the
-// engine happens to keep. Neither can build on what it produced last frame, and
-// a whole class of effect is nothing but that:
-//
-//   Fog that a dancer walks through does not "look displaced near her" — it IS
-//   displaced, and stays displaced, and creeps back over seconds. Water does not
-//   look rippled where a foot landed; a ripple leaves and propagates and
-//   reflects off the far edge long after the foot is gone. Both are the same
-//   shape of thing — a grid, stepped by its own previous value.
-//
-// It is also the only way to get the LOOK of a fluid, not merely its motion.
-// Advection compounds: each frame's field is the last one pushed sideways, and a
-// few hundred frames of that stretches and folds a smooth field into filaments
-// and vortex sheets finer than the grid storing them. No noise function
-// produces that, at any octave count, because the structure is not a function of
-// position at all — it is a function of history.
-//
-// The engine owns the ping-pong, the dispatch and the sampling. The author owns
-// the KERNEL, which is the part that differs: advection for smoke, the wave
-// equation for water, a decaying stamp for footprints. That split is the same
-// one the particle mounts make, and for the same reason — the loop is identical
-// in every such effect and the physics never is.
-// A megatexel of rgba16float is 8MB, and two of those is the whole cost. What
-// actually bounds this is the STEP: one invocation per texel per frame, each
-// taking a dozen samples, so doubling the side quadruples the work.
-export const SIM_MAX = 1024;
-/** rgba16float, ping-ponged. Two of these is the whole memory cost. */
-export const SIM_FORMAT = "rgba16float";
-/** `// @sim 256` — the grid's resolution, in texels per side. */
-export function parseSimSize(wgsl, max) {
-    const m = /^\s*\/\/\s*@sim\s+(\d+)\s*$/m.exec(wgsl);
-    if (!m)
-        return 0;
-    // Clamped rather than rejected, as the particle count is: an author asking for
-    // 4096 gets the most the engine will give and a scene that still runs.
-    return Math.max(8, Math.min(max, parseInt(m[1], 10)));
-}
-/** Whether this effect drives a grid at all. */
-export function simEntryPoint(wgsl) {
-    return /\bfn\s+simStep\s*\(/.test(wgsl);
-}
-/**
- * `rzSim(uv)`, for a shader that READS the grid rather than steps it.
- *
- * Always compiled in, even for an effect with no grid — it then samples a 1×1
- * of zeroes. An accessor that exists only sometimes is one an author has to
- * guard, and a missing function is a compile error rather than a blank result.
- */
-export function simReadApi(group, tex, samp, size) {
-    return /* wgsl */ `
-const RZ_SIM_SIZE: f32 = ${size > 0 ? size : 1}.0;
-@group(${group}) @binding(${tex}) var _rzSimTex: texture_2d<f32>;
-@group(${group}) @binding(${samp}) var _rzSimSamp: sampler;
-
-/**
- * The grid, bilinearly sampled. uv is 0..1 across it, and what that MEANS in
- * the world is the effect's own business — the engine deliberately does not
- * impose a mapping, because a fog laid over a stage and a ripple field around a
- * character want different ones and both are two lines of arithmetic.
- */
-fn rzSim(uv: vec2f) -> vec4f {
-  return textureSampleLevel(_rzSimTex, _rzSimSamp, clamp(uv, vec2f(0.0), vec2f(1.0)), 0.0);
-}
-fn rzSimSize() -> f32 { return RZ_SIM_SIZE; }
-fn rzSimTexel() -> f32 { return 1.0 / RZ_SIM_SIZE; }
-
-// ── The step-only half, defined here too and never called here ──
-//
-// One effect file is spliced into EVERY module it has a mount in, so a file
-// with a grid compiles its simStep inside the field and particle shaders as
-// well — where it is dead code that nothing calls, but still code that has to
-// resolve. Leaving these out is a compile error on a function the author was
-// right to write. rzSimPrev reads the current grid rather than a previous one,
-// which is the honest answer outside the step: there is no previous frame here.
-fn rzSimPrev(uv: vec2f) -> vec4f { return rzSim(uv); }
-fn rzSimFrame() -> i32 { return 1; }
-`;
-}
-/** `rzTime`/`rzDt`, for a module that has no clock of its own — the field pass.
- *  Same reason as above: a spliced simStep refers to them. */
-export function simClockApi(timeExpr) {
-    return /* wgsl */ `
-fn rzTime() -> f32 { return ${timeExpr}; }
-fn rzDt() -> f32 { return 0.0; }
-`;
-}
-const SIM_UNIFORMS = /* wgsl */ `
-struct SimU {
-  time: f32,
-  dt: f32,
-  size: f32,
-  frame: f32,
-}
-`;
-/**
- * The step shader: one invocation per texel, once per frame.
- *
- * The previous grid is bound as a SAMPLED texture and the next as a storage
- * texture, which is what makes the two different resources and the whole thing
- * legal — a shader cannot read and write one texture coherently, and the
- * ping-pong is not an optimisation but the only correct way to do this.
- *
- * Sampled rather than only fetched, because advection needs to read BETWEEN
- * texels: a semi-Lagrangian step asks "what was at the place this parcel came
- * from", and that place is almost never a texel centre. Point-sampling it is
- * what turns smoke into a staircase.
- */
-export function buildSimShader(wgsl, size, _cast) {
-    return (SIM_UNIFORMS +
-        /* wgsl */ `
-@group(0) @binding(0) var<uniform> su: SimU;
-@group(0) @binding(1) var _rzSimPrevTex: texture_2d<f32>;
-@group(0) @binding(2) var _rzSimSamp: sampler;
-@group(0) @binding(3) var _rzSimOut: texture_storage_2d<${SIM_FORMAT}, write>;
-@group(0) @binding(4) var<storage, read> _rzCast: array<vec4f>;
-// The same view uniform the composite reads, so the scene API below is the real
-// thing here rather than a stub — a kernel can ask where a bone is, and a
-// foreground spliced into this module resolves its camera calls.
-@group(0) @binding(6) var<uniform> viewU: array<vec4<f32>, 15>;
-
-fn rzTime() -> f32 { return su.time; }
-fn rzDt() -> f32 { return su.dt; }
-/** Texels per side. */
-fn rzSimSize() -> f32 { return su.size; }
-/** One texel, in uv — the step a neighbour lookup takes. */
-fn rzSimTexel() -> f32 { return 1.0 / su.size; }
-/**
- * Steps since this effect was installed. Zero on the very first one, which is
- * the only chance to seed a grid: everything after it builds on what is there.
- */
-fn rzSimFrame() -> i32 { return i32(su.frame); }
-
-/** The grid as it was LAST frame, bilinear. The only input a kernel really has. */
-fn rzSimPrev(uv: vec2f) -> vec4f {
-  return textureSampleLevel(_rzSimPrevTex, _rzSimSamp, clamp(uv, vec2f(0.0), vec2f(1.0)), 0.0);
-}
-` +
-        EFFECT_SCENE_API +
-        audioApi(0, 5) +
-        scoreApi(0, 7) +
-        // rzSim itself, so a kernel may read the grid it is writing — through the
-        // PREVIOUS frame's texture, which is the only version of it that exists
-        // while the current one is still being written.
-        /* wgsl */ `
-fn rzSim(uv: vec2f) -> vec4f { return rzSimPrev(uv); }
-` +
-        "\n// ── user effect (setEffect) ──\n" +
-        wgsl +
-        /* wgsl */ `
-
-@compute @workgroup_size(8, 8)
-fn main(@builtin(global_invocation_id) gid: vec3u) {
-  let n = u32(${size});
-  if (gid.x >= n || gid.y >= n) { return; }
-  let xy = vec2i(i32(gid.x), i32(gid.y));
-  // The texel CENTRE, so a kernel that reads its own uv back through rzSimPrev
-  // lands on itself rather than a quarter-texel off.
-  let uv = (vec2f(f32(gid.x), f32(gid.y)) + vec2f(0.5)) / su.size;
-  textureStore(_rzSimOut, xy, simStep(uv, textureLoad(_rzSimPrevTex, xy, 0), su.dt));
-}
-`);
-}

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

@@ -1,10 +0,0 @@
-/** 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

@@ -1 +0,0 @@
-{"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

@@ -1,114 +0,0 @@
-// 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);
-}
-`;
-}