reze-engine 0.42.3 → 0.50.0

package/dist/shaders/materials/common.js

@@ -1,3 +1,7 @@
+import { sceneFsOutWgsl } from "../passes/scene-contract";
+import { lightsApi } from "../lights";
+import { SHADOW_CASCADES } from "../../shadow-cascades";
+import { WORLD_AMBIENT_WGSL } from "../lights";
 // Shared WGSL blocks concatenated by every material shader.
 // Splits the boilerplate (uniform structs, bind group layout, skinning VS, PCF shadow)
 // away from the per-material fragment code so each material file only contains what
@@ -35,6 +39,8 @@ struct Light {
 struct LightUniforms {
   ambientColor: vec4f,
   lights: array<Light, 4>,
+  /** Irradiance SH of the HDRI world; [0].w is the on-flag. */
+  sh: array<vec4f, 9>,
 };
 
 // Per-material uniforms. Every material binds this layout even if it ignores fields;
@@ -51,8 +57,15 @@ struct MaterialUniforms {
   // Skeleton index of the 頭 (head) bone, or -1. Lets the eye shader gate
   // the post-alpha-eye stencil by camera-vs-face hemisphere.
   headBoneIndex: f32,
-  _pad0: f32,
-  _pad1: f32,
+  // The draw's identity, for the id attachment: which material, which object.
+  // They ride HERE, in padding this struct already carried, so the buffer's
+  // size and layout are untouched and the indirect-draw path keeps working —
+  // the ids arrive with the same per-draw uniform the material already binds,
+  // rather than needing a channel of their own. Zero while ids are off, and
+  // zero is the reserved "nothing" value, so reading them then is not wrong,
+  // just empty. f32 because the buffer is written as floats; the shader casts.
+  materialId: f32,
+  objectId: f32,
   _pad2: f32,
 };
 
@@ -70,7 +83,9 @@ struct VertexOutput {
   @location(3) restPos: vec3f,
 };
 
-struct LightVP { viewProj: mat4x4f, };
+// One view-projection per shadow cascade, inner to outer — the volumes built
+// by shadow-cascades.ts, in the same order.
+struct LightVP { viewProj: array<mat4x4f, ${SHADOW_CASCADES.length}>, };
 
 @group(0) @binding(0) var<uniform> camera: CameraUniforms;
 @group(0) @binding(1) var<uniform> light: LightUniforms;
@@ -78,6 +93,10 @@ struct LightVP { viewProj: mat4x4f, };
 @group(0) @binding(3) var shadowMap: texture_depth_2d;
 @group(0) @binding(4) var shadowSampler: sampler_comparison;
 @group(0) @binding(5) var<uniform> lightVP: LightVP;
+// The far cascade's map — coarser texels over a much wider box, so the stage
+// keeps its shadows when the crisp near volume ends. Binding 7: 6 is the
+// positional lights, 9 the BRDF LUT.
+@group(0) @binding(7) var shadowMapFar: texture_depth_2d;
 // binding(9) brdfLut is declared inside NODES_WGSL (nodes.ts).
 @group(1) @binding(0) var<storage, read> skinMats: array<mat4x4f>;
 @group(2) @binding(0) var diffuseTexture: texture_2d<f32>;
@@ -108,32 +127,60 @@ fn safe_normal(nIn: vec3f) -> vec3f {
 }
 
 `;
-// ─── Shadow sampler (3×3 PCF) ───────────────────────────────────────
-// 4096-map (MUST match Engine.SHADOW_MAP_SIZE), normal-bias 0.08, depth-bias
-// 0.001. Unrolled — Safari's Metal backend doesn't unroll nested shadow loops
-// reliably. The texel size was stale at 1/2048 after the map grew to 4096:
-// PCF taps landed TWO texels apart, quantizing self-shadow edges into
-// texel-sized gray/black squares that crawled with the animation.
-export const SAMPLE_SHADOW_WGSL = /* wgsl */ `
+// ─── Shadow sampler (3×3 PCF, cascade-selected) ─────────────────────
+// Normal-bias 0.08, depth-bias 0.001 NDC. Unrolled — Safari's Metal backend
+// doesn't unroll nested shadow loops reliably. Texel sizes are interpolated
+// from SHADOW_CASCADES so they cannot go stale the way the hardcoded 1/2048
+// once did (PCF taps landed TWO texels apart after the map grew to 4096,
+// quantizing self-shadow edges into crawling gray squares).
+//
+// Selection: the crisp near cascade wherever its box covers the point — with a
+// margin that keeps the whole PCF kernel inside the map, so selection never
+// mixes maps mid-kernel — else the far cascade, else LIT. Lit is a fix, not
+// merely a default: the old single-volume path clamped, and past the light's
+// far plane the comparison failed against every stored depth, silently
+// shadowing any stage deeper than the box.
+const pcf9 = (map, ts) => /* wgsl */ `
+  let suv = vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);
+  let cmpZ = ndc.z - 0.001;
+  let ts = ${ts};
+  let s00 = textureSampleCompareLevel(${map}, shadowSampler, suv + vec2f(-ts, -ts), cmpZ);
+  let s10 = textureSampleCompareLevel(${map}, shadowSampler, suv + vec2f(0.0, -ts), cmpZ);
+  let s20 = textureSampleCompareLevel(${map}, shadowSampler, suv + vec2f( ts, -ts), cmpZ);
+  let s01 = textureSampleCompareLevel(${map}, shadowSampler, suv + vec2f(-ts, 0.0), cmpZ);
+  let s11 = textureSampleCompareLevel(${map}, shadowSampler, suv, cmpZ);
+  let s21 = textureSampleCompareLevel(${map}, shadowSampler, suv + vec2f( ts, 0.0), cmpZ);
+  let s02 = textureSampleCompareLevel(${map}, shadowSampler, suv + vec2f(-ts,  ts), cmpZ);
+  let s12 = textureSampleCompareLevel(${map}, shadowSampler, suv + vec2f(0.0,  ts), cmpZ);
+  let s22 = textureSampleCompareLevel(${map}, shadowSampler, suv + vec2f( ts,  ts), cmpZ);
+  return (s00 + s10 + s20 + s01 + s11 + s21 + s02 + s12 + s22) * (1.0 / 9.0);
+`;
+const SAMPLE_SHADOW_WGSL = /* wgsl */ `
+
+fn sampleShadowNear(ndc: vec3f) -> f32 {
+${pcf9("shadowMap", `1.0 / ${SHADOW_CASCADES[0].mapSize}.0`)}
+}
+
+fn sampleShadowFar(ndc: vec3f) -> f32 {
+${pcf9("shadowMapFar", `1.0 / ${SHADOW_CASCADES[SHADOW_CASCADES.length - 1].mapSize}.0`)}
+}
 
 fn sampleShadow(worldPos: vec3f, n: vec3f) -> f32 {
   if (dot(n, -light.lights[0].direction.xyz) <= 0.0) { return 0.0; }
   let biasedPos = worldPos + n * 0.08;
-  let lclip = lightVP.viewProj * vec4f(biasedPos, 1.0);
-  let ndc = lclip.xyz / max(lclip.w, 1e-6);
-  let suv = vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);
-  let cmpZ = ndc.z - 0.001;
-  let ts = 1.0 / 4096.0;
-  let s00 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f(-ts, -ts), cmpZ);
-  let s10 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f(0.0, -ts), cmpZ);
-  let s20 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f( ts, -ts), cmpZ);
-  let s01 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f(-ts, 0.0), cmpZ);
-  let s11 = textureSampleCompareLevel(shadowMap, shadowSampler, suv, cmpZ);
-  let s21 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f( ts, 0.0), cmpZ);
-  let s02 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f(-ts,  ts), cmpZ);
-  let s12 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f(0.0,  ts), cmpZ);
-  let s22 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f( ts,  ts), cmpZ);
-  return (s00 + s10 + s20 + s01 + s11 + s21 + s02 + s12 + s22) * (1.0 / 9.0);
+  let c0 = lightVP.viewProj[0] * vec4f(biasedPos, 1.0);
+  let n0 = c0.xyz / max(c0.w, 1e-6);
+  if (all(abs(n0.xy) < vec2f(0.98)) && n0.z > 0.0 && n0.z < 1.0) {
+    return sampleShadowNear(n0);
+  }
+  let c1 = lightVP.viewProj[1] * vec4f(biasedPos, 1.0);
+  let n1 = c1.xyz / max(c1.w, 1e-6);
+  if (all(abs(n1.xy) < vec2f(0.98)) && n1.z > 0.0 && n1.z < 1.0) {
+    return sampleShadowFar(n1);
+  }
+  // Outside every cascade there is no occlusion information; lit is the only
+  // honest answer.
+  return 1.0;
 }
 
 `;
@@ -142,7 +189,7 @@ fn sampleShadow(worldPos: vec3f, n: vec3f) -> f32 {
 // (PMX models occasionally ship with unnormalized weights on extras like hair tips).
 // VS normalize on the outgoing normal is skipped — interpolation denormalizes it
 // anyway and every fragment shader does `normalize(input.normal)` as its first line.
-export const COMMON_VS_WGSL = /* wgsl */ `
+const COMMON_VS_WGSL = /* wgsl */ `
 
 @vertex fn vs(
   @location(0) position: vec3f,
@@ -192,15 +239,20 @@ export const COMMON_VS_WGSL = /* wgsl */ `
 // src-alpha blending enabled:
 //   out.r = mask_r · src.a + dst.r · (1-src.a)   (bloom mask, weighted by alpha)
 //   out.g = 1.0    · src.a + dst.g · (1-src.a)   (canonical premultiplied alpha-over)
-export const COMMON_FS_OUT_WGSL = /* wgsl */ `
-
-struct FSOut {
-  @location(0) color: vec4f,
-  @location(1) mask: vec4f,
-};
-
-`;
+// The struct itself comes from scene-contract, which owns what the scene pass's
+// attachments ARE — this is one of the two shaders that gains an output when
+// one is added, and the graph generator emits against this same declaration.
+//
+// A FUNCTION, and no longer part of the prelude constant below, because the id
+// attachment is a device capability probed at init: a struct baked at import
+// time would be built before the answer exists. The graph appends it where the
+// constant used to end, so the assembled module is unchanged.
+export function commonFsOutWgsl() {
+    return `\n\n${sceneFsOutWgsl()}\n`;
+}
 // ─── Convenience: full shared prelude ───────────────────────────────
 // Material files compose this as `${NODES_WGSL}${COMMON_MATERIAL_PRELUDE_WGSL}` to
 // pull in everything structural. Each material then adds its own constants + fs().
-export const COMMON_MATERIAL_PRELUDE_WGSL = COMMON_BINDINGS_WGSL + SAMPLE_SHADOW_WGSL + COMMON_VS_WGSL + COMMON_FS_OUT_WGSL;
+// The FSOut struct is NOT in here any more — see commonFsOutWgsl above. Every
+// consumer of this constant appends it immediately, which is where it was.
+export const COMMON_MATERIAL_PRELUDE_WGSL = COMMON_BINDINGS_WGSL + WORLD_AMBIENT_WGSL + lightsApi(0, 6) + SAMPLE_SHADOW_WGSL + COMMON_VS_WGSL;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"midi-api.d.ts","sourceRoot":"","sources":["../../src/shaders/midi-api.ts"],"names":[],"mappings":"AA8BA,+EAA+E;AAC/E,eAAO,MAAM,WAAW,IAAI,CAAA;AAC5B,iFAAiF;AACjF,eAAO,MAAM,SAAS,MAAM,CAAA;AAC5B,oCAAoC;AACpC,eAAO,MAAM,UAAU,QAA0B,CAAA;AACjD,yDAAyD;AACzD,eAAO,MAAM,WAAW,IAAI,CAAA;AAE5B,gBAAgB,CAChB,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CA2E9D"}

package/dist/shaders/midi-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 MIDI_HEADER = 8;
+/** One energy slot per MIDI pitch. 128 is the MIDI range, not a cap we chose. */
+export const MIDI_KEYS = 128;
+/** Where the note records begin. */
+export const MIDI_NOTES = MIDI_HEADER + MIDI_KEYS;
+/** Floats per note: start, duration, pitch, velocity. */
+export const MIDI_STRIDE = 4;
+/** The rzNote*/ /* rzKey* accessors, with the buffer declared at the given binding. */
+export function midiApi(group, binding) {
+    return /* wgsl */ `
+@group(${group}) @binding(${binding}) var<storage, read> _rzMidi: 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(_rzMidi[0]); }
+/** Where the score is NOW, in seconds — the clock every age below hangs from. */
+fn rzMidiTime() -> f32 { return _rzMidi[3]; }
+/** 1 while the score is advancing, 0 paused or absent. */
+fn rzMidiPlaying() -> f32 { return select(0.0, _rzMidi[4], i32(_rzMidi[0]) > 0); }
+/** Last note-off, in seconds — the length of the piece. */
+fn rzMidiDuration() -> f32 { return _rzMidi[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 _rzMidi[1]; }
+fn rzPitchHigh() -> f32 { return _rzMidi[2]; }
+
+fn _rzNoteAt(i: i32, field: i32) -> f32 {
+  if (i < 0 || i >= i32(_rzMidi[0])) { return 0.0; }
+  return _rzMidi[${MIDI_NOTES} + i * ${MIDI_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 _rzMidi[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 >= ${MIDI_KEYS}) { return 0.0; }
+  return _rzMidi[${MIDI_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 = _rzMidi[1];
+  let hi = _rzMidi[2];
+  return select(0.5, (pitch - lo) / max(hi - lo, 1.0), hi > lo);
+}
+`;
+}

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

@@ -54,21 +54,8 @@ export declare function parseEffectAnchors(wgsl: string, max: number): {
     bone: string;
     trail: boolean;
 }[];
-/**
- * The caps the cast buffer is built to, shared by the shader below and by the
- * engine that fills it. Interpolated into the WGSL rather than written twice:
- * the layout arithmetic on both sides has to agree exactly, and two literals
- * that must match are two literals that eventually will not.
- *
- * All three are MINIMUMS. Raising one breaks nothing, because effects read
- * through accessors and loop to the count functions; lowering one does.
- */
-export declare const EFFECT_SUBJECTS = 4;
-export declare const EFFECT_ANCHORS = 8;
-export declare const EFFECT_TRAIL_SAMPLES = 128;
-/** vec4 slot where the trails begin — after the subjects and the anchors. */
-export declare const EFFECT_TRAIL_BASE: number;
-export type CompositeEffectSource = {
+export { EFFECT_ANCHORS, EFFECT_SUBJECTS, EFFECT_TRAIL_BASE, EFFECT_TRAIL_SAMPLES } from "../cast-layout";
+type CompositeEffectSource = {
     /** The user's WGSL verbatim: helpers plus whichever entry points it defines. */
     wgsl: string;
     /** Codegen'd `struct EffectParams {...}` + binding decl; empty when no params. */
@@ -77,8 +64,37 @@ export type CompositeEffectSource = {
     hasBackground: boolean;
     /** Defines `fn foreground(...)` — mount over the finished frame. */
     hasForeground: boolean;
+    /** Grid resolution when the effect declared `// @grid`, else 0. */
+    gridSize: number;
+    /** Whether the scene pass carries the id attachment, so the field module can
+     *  bind it. False emits accessors that answer 0 rather than nothing at all. */
+    ids?: boolean;
+    /** How many of this effect's anchors asked for a trail — RZ_TRAIL_SLOTS,
+     *  which a hosted particle or trail loop reads even in this module. REQUIRED,
+     *  and deliberately not defaulted: a silent 0 is a ribbon loop that iterates
+     *  nothing, which looks exactly like an effect that drew nothing. */
+    trailCount: number;
+    /** This effect's local anchor slot → scene slot, from the shared table.
+     *  Omitted or identity when it owns the table. The particle and trail modules
+     *  have always taken this; the field module not taking it was the bug. */
+    alias?: number[];
 };
+/**
+ * The scene half of the effect API — camera, projection, cast, trails.
+ *
+ * Split out of COMPOSITE_HEAD so the SIM pass can have it too. One effect file
+ * is spliced into every module it has a mount in, so a file with both a grid and
+ * a foreground compiles its foreground inside the grid shader, where every
+ * rzCameraPos() in it has to resolve. Sharing the block is better than stubbing
+ * it twice, and it means a kernel can legitimately ask where a bone is — which
+ * is exactly what a wake wants.
+ *
+ * Depends on `viewU` and `_rzCast` being declared by the including module, and
+ * on nothing else: no textures, no samplers.
+ */
+export declare const EFFECT_SCENE_API = "\n// \u2500\u2500 The effect API \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// Named rz*, for the engine. The prefix earns its place twice: user code is\n// concatenated into THIS module, so an unprefixed rzAnchor() would collide with\n// exactly the helper an author would write, and the old bg* prefix stopped being\n// true in 0.41.0 when effects gained a mount over the finished frame.\n//\n// The bg* names below are permanent aliases, not a deprecation with an end date.\n// A published link is immutable, so a scene pinned to a bg* effect has to keep\n// compiling forever. They are one-line and inlined; no new function gets one.\n\n/** Canvas size in pixels \u2014 for aspect correction. */\nfn rzResolution() -> vec2f { return viewU[6].zw; }\n\n/** The camera's world position. */\nfn rzCameraPos() -> vec3f { return viewU[10].xyz; }\n\n/** How many characters are in the scene, up to four. */\nfn rzSubjectCount() -> i32 { return i32(viewU[10].w); }\n\n/**\n * A world point as the camera sees it: xy the uv it lands on, z its distance\n * along the VIEW AXIS in metres.\n *\n * The exact inverse of the ray this pass builds per pixel, so it is the cheap way\n * to work with anything anchored in the world. Marching a curve or a trail in 3D\n * costs a distance evaluation per sample per pixel; projecting its points once\n * and measuring in 2D costs a subtraction, which is the difference between a\n * ribbon that runs at 4K and one that does not.\n *\n * z is directly comparable to the depth handed to foreground(), so occlusion is\n * a single test: draw where your z is nearer than the scene's. It is returned\n * SIGNED and unclamped \u2014 behind the camera is negative, and worth rejecting\n * before you use the uv, which is meaningless there.\n */\nfn rzProject(p: vec3f) -> vec3f {\n  let d = p - viewU[10].xyz;\n  let z = dot(d, viewU[5].xyz);\n  // Guard only the divide. z itself is returned as it is, so the caller can see\n  // the sign; clamping it here would put points behind the lens on the horizon.\n  let inv = 1.0 / select(z, 1e-4, z < 1e-4);\n  let ndc = vec2f(dot(d, viewU[3].xyz) * inv / viewU[3].w, dot(d, viewU[4].xyz) * inv / viewU[4].w);\n  return vec3f(ndc * 0.5 + 0.5, z);\n}\n\nfn rzCamPos() -> vec3f { return rzCameraPos(); }\nfn rzCameraRight() -> vec3f { return viewU[3].xyz; }\nfn rzCameraUp() -> vec3f { return viewU[4].xyz; }\nfn rzCameraForward() -> vec3f { return viewU[5].xyz; }\n\n// The cast \u2014 subjects, anchors, trails \u2014 is CAST_API, shared verbatim with the\n// particle and trail modules. It used to be written out here, a second time, and\n// the two copies had drifted: this one had rzAnchor and that one did not.\n\nconst RZ_SUBJECTS: i32 = 4;\nconst RZ_SAMPLES: i32 = 128;\n/** The anchor ADDRESS SPACE \u2014 how many an effect may declare, not how many it\n *  did. RZ_TRAIL_SLOTS is the per-effect number and is not this one; the two\n *  being one number was the old trail bug. */\nconst RZ_MAX_ANCHORS: i32 = 8;\nconst RZ_TRAIL_SAMPLES: i32 = 128;\n\nstruct RzSubject {\n  /** On the FLOOR, under the body \u2014 where a ring or a magic circle belongs. */\n  root: vec3f,\n  /** At the hips, the middle of the body \u2014 where an aura belongs. */\n  center: vec3f,\n  /** Bounding sphere: xyz centre, w radius. Deliberately generous \u2014 cull with it. */\n  bounds: vec4f,\n  /** False past the end of the cast, and every field is then zero. */\n  valid: bool,\n}\n\nstruct RzAnchor {\n  pos: vec3f,\n  /** World units per second, from the previous frame. Direction for a trail,\n   *  magnitude for anything that should react to how hard someone is moving. */\n  vel: vec3f,\n  /** The bone's forward axis \u2014 which way a foot points, where a head looks. */\n  fwd: vec3f,\n  /** False when this rig has no such bone. Check it: the alternative is drawing\n   *  a hand effect at the world origin on every model that spells it differently. */\n  valid: bool,\n}\n\n/** Which model this is, stable across a scene \u2014 for per-subject variation. */\nfn rzSubjectId(i: i32) -> u32 {\n  if (i < 0 || i >= rzSubjectCount()) { return 0u; }\n  return u32(_rzCast[i * 3 + 1].w);\n}\n\nfn rzSubject(i: i32) -> RzSubject {\n  var s: RzSubject;\n  s.valid = i >= 0 && i < rzSubjectCount();\n  if (!s.valid) { return s; }\n  let b = i * 3;\n  s.root = _rzCast[b].xyz;\n  s.center = _rzCast[b + 1].xyz;\n  s.bounds = _rzCast[b + 2];\n  return s;\n}\n\n/**\n * Where a named bone is, this frame.\n *\n * The slot is the author's own: the Nth @anchor in their file, in the order\n * they wrote them. _rzSlot turns that into the scene's address, which is what\n * keeps two effects that both anchor to a wrist from reading each other's.\n */\nfn rzAnchor(subject: i32, slot: i32) -> RzAnchor {\n  var a: RzAnchor;\n  a.valid = false;\n  let g = _rzSlot(slot);\n  if (subject < 0 || subject >= rzSubjectCount() || g < 0 || g >= RZ_MAX_ANCHORS) { return a; }\n  let b = 12 + (g * 4 + subject) * 3;\n  a.valid = _rzCast[b].w > 0.5;\n  a.pos = _rzCast[b].xyz;\n  a.vel = _rzCast[b + 1].xyz;\n  a.fwd = _rzCast[b + 2].xyz;\n  return a;\n}\n\n/**\n * How many samples of a path are recorded \u2014 0 for an anchor that asked for no\n * trail, and for one that has not moved yet.\n *\n * Bounded by the anchor cap, NOT by how many anchors asked for a trail. Those\n * are different index spaces: storage is addressed by anchor slot, so an\n * untrailed @anchor followed by a trailed one put the trail at index 1 with a\n * bound of 1 and rzTrail returned zero \u2014 a ribbon that silently did not draw.\n */\nfn rzTrailCount(subject: i32, slot: i32) -> i32 {\n  let g = _rzSlot(slot);\n  if (subject < 0 || subject >= rzSubjectCount() || g < 0 || g >= RZ_MAX_ANCHORS) { return 0; }\n  return i32(_rzCast[12 + (g * 4 + subject) * 3 + 2].w);\n}\n\n/** Sample i of a path: xyz where it was, w how many seconds ago. i = 0 is now. */\nfn rzTrail(subject: i32, slot: i32, i: i32) -> vec4f {\n  let n = rzTrailCount(subject, slot);\n  if (i < 0 || i >= n) { return vec4f(0.0); }\n  let base = 108 + (_rzSlot(slot) * 4 + subject) * RZ_TRAIL_SAMPLES;\n  return _rzCast[base + i];\n}\n\n\n// The hashes, the noise and rzFalloff \u2014 EFFECT_MATH_API, the same text the\n// particle and trail modules get. The field module used to be missing most of\n// it, so a helper an author wrote for one mount failed to compile in another\n// for no reason visible in the file.\n\nfn rzHash11(x: f32) -> f32 {\n  var p = fract(x * 0.1031);\n  p = p * (p + 33.33);\n  return fract(p * (p + p));\n}\nfn rzHash21(p: vec2f) -> f32 {\n  var p3 = fract(vec3f(p.x, p.y, p.x) * 0.1031);\n  p3 = p3 + dot(p3, p3.yzx + 33.33);\n  return fract((p3.x + p3.y) * p3.z);\n}\n/** Three independent randoms from one seed \u2014 the usual need when spawning. */\nfn rzHash13(x: f32) -> vec3f {\n  return vec3f(rzHash11(x), rzHash11(x + 17.13), rzHash11(x + 41.71));\n}\n/**\n * Compact-support falloff: 1 at the centre, exactly 0 at r, smooth between.\n *\n * It reaches exactly zero rather than merely getting small, because a glow that\n * never quite ends has to be culled somewhere, and culling it wherever it looks\n * close enough is what put a visible hard edge on the first halo effect.\n */\nfn rzFalloff(d: f32, r: f32) -> f32 {\n  let x = clamp(d / max(r, 1e-6), 0.0, 1.0);\n  let f = 1.0 - x;\n  return f * f * f;\n}\nfn rzHash31(p: vec3f) -> f32 {\n  var p3 = fract(p * 0.1031);\n  p3 = p3 + dot(p3, p3.zyx + 31.32);\n  return fract((p3.x + p3.y) * p3.z);\n}\nfn rzValueNoise(p: vec3f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  let n000 = rzHash31(i);\n  let n100 = rzHash31(i + vec3f(1.0, 0.0, 0.0));\n  let n010 = rzHash31(i + vec3f(0.0, 1.0, 0.0));\n  let n110 = rzHash31(i + vec3f(1.0, 1.0, 0.0));\n  let n001 = rzHash31(i + vec3f(0.0, 0.0, 1.0));\n  let n101 = rzHash31(i + vec3f(1.0, 0.0, 1.0));\n  let n011 = rzHash31(i + vec3f(0.0, 1.0, 1.0));\n  let n111 = rzHash31(i + vec3f(1.0, 1.0, 1.0));\n  let x00 = mix(n000, n100, u.x);\n  let x10 = mix(n010, n110, u.x);\n  let x01 = mix(n001, n101, u.x);\n  let x11 = mix(n011, n111, u.x);\n  return mix(mix(x00, x10, u.y), mix(x01, x11, u.y), u.z);\n}\n/** Divergence-free flow \u2014 the field a wisp of smoke follows without a solver. */\nfn rzCurlNoise(p: vec3f) -> vec3f {\n  let e = 0.1;\n  let dx = vec3f(e, 0.0, 0.0);\n  let dy = vec3f(0.0, e, 0.0);\n  let dz = vec3f(0.0, 0.0, e);\n  let x0 = rzValueNoise(p - dx); let x1 = rzValueNoise(p + dx);\n  let y0 = rzValueNoise(p - dy); let y1 = rzValueNoise(p + dy);\n  let z0 = rzValueNoise(p - dz); let z1 = rzValueNoise(p + dz);\n  return normalize(vec3f((y1 - y0) - (z1 - z0), (z1 - z0) - (x1 - x0), (x1 - x0) - (y1 - y0)) + vec3f(1e-6));\n}\n\nstruct Particle {\n  pos: vec3f,\n  age: f32,\n  vel: vec3f,\n  life: f32,\n  size: f32,\n  rot: f32,\n  seed: f32,\n  // Aspect along the direction of travel. 1 or less is a square billboard; a\n  // raindrop is 10 or 20. Zero-initialised, so an effect that never sets it gets\n  // the square it expects.\n  stretch: f32,\n}\n\n\n\nfn bgResolution() -> vec2f { return rzResolution(); }\nfn bgCameraPos() -> vec3f { return rzCameraPos(); }\nfn bgSubjectCount() -> i32 { return rzSubjectCount(); }\n\n/**\n * Where a character IS, in world space \u2014 at the hips, not on the floor.\n *\n * An effect that wants to RESPOND to the cast \u2014 a glow that follows someone,\n * dust kicked up where they are \u2014 needs to know where they are, and the ray and\n * the depth cannot tell it: they describe the pixel, not the scene.\n *\n * The value is model.position + \u30BB\u30F3\u30BF\u30FC + \u5168\u3066\u306E\u89AA. \u30BB\u30F3\u30BF\u30FC sits at hip\n * height on every standard MMD rig, so this is a point in the middle of the\n * body. It is NOT the contact point: a ripple drawn here appears at the waist.\n * Ground effects want the .xz of this and their own floor height, which is what\n * the effects that shipped against it already do.\n *\n * The comment here used to claim it was \"between the feet on the floor\", which\n * is where that habit came from. Left as it is regardless of the name: a\n * published link is immutable, so every shared scene pinning an effect that\n * reads this depends on it meaning exactly what it has always meant.\n *\n * Clamped rather than bounds-checked: an effect looping past the count reads the\n * last subject instead of sampling whatever follows the array, which is a wrong\n * ripple rather than an undefined one.\n */\nfn rzSubjectHip(i: i32) -> vec3f { return viewU[11 + clamp(i, 0, 3)].xyz; }\n\nfn bgSubjectPos(i: i32) -> vec3f { return rzSubjectHip(i); }\n\n/** Where in the WORLD the scene drew this pixel \u2014 the depth handed to\n *  foreground() turned into a place. Without it an effect can only think in\n *  distances from the lens, which is no use to anything that belongs somewhere:\n *  fog lying on the ground has to know where the ground is.\n *\n *  depth measures along the VIEW AXIS, not along the ray, so it is divided by\n *  the ray's projection onto camera-forward before being walked out. At the far\n *  plane (nothing drawn) this lands a very long way off, which is what a sky\n *  should do to anything reading it. */\nfn rzWorldPos(ray: vec3f, depth: f32) -> vec3f {\n  let axis = max(dot(normalize(ray), viewU[5].xyz), 1e-4);\n  return rzCameraPos() + normalize(ray) * (depth / axis);\n}\n\nfn bgWorldPos(ray: vec3f, depth: f32) -> vec3f { return rzWorldPos(ray, depth); }\n\n/** What an effect returns for one of its lights. */\nstruct RzLight {\n  pos: vec3f,\n  color: vec3f,\n  intensity: f32,\n  radius: f32,\n}\n\n\n/** Color grading, applied to the tonemapped SCENE (not the background \u2014 see the\n *  call site). The core is ASC CDL, the film-industry interchange standard:\n *\n *      out = (in \u00B7 slope + offset) ^ power        then saturation  (SOP \u2192 SAT)\n *\n *  Using the real standard rather than invented controls means a look authored\n *  here maps onto any grading tool. slope/offset/power are derived on the CPU\n *  from the UI's shadow/midtone/highlight colors (see setColorGrading), so the\n *  per-pixel cost is one mul-add, one pow, one lerp. */\nfn grade(c: vec3f) -> vec3f {\n  var x = pow(max(c * viewU[9].xyz + viewU[7].xyz, vec3f(0.0)), viewU[8].xyz);\n  // Contrast pivots on 0.5 \u2014 display-referred midpoint, since we grade post-Filmic.\n  x = (x - vec3f(0.5)) * viewU[7].w + vec3f(0.5);\n  // Rec.709 luma, matching the ASC SAT node.\n  let luma = dot(x, vec3f(0.2126, 0.7152, 0.0722));\n  return max(mix(vec3f(luma), x, viewU[8].w), vec3f(0.0));\n}\n";
 export declare function buildCompositeShader(effect?: CompositeEffectSource | null): string;
+export declare function buildFieldShader(effect: CompositeEffectSource): string;
 /** Kept for compatibility with existing imports (the base, no-effect shader). */
 export declare const COMPOSITE_SHADER_WGSL: string;
 //# sourceMappingURL=composite.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"composite.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/composite.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAgC+B;AAC/B;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,EAAE,CAIhG;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,IAAI,CAAA;AAChC,eAAO,MAAM,cAAc,IAAI,CAAA;AAC/B,eAAO,MAAM,oBAAoB,MAAM,CAAA;AACvC,6EAA6E;AAC7E,eAAO,MAAM,iBAAiB,QAA6D,CAAA;AAE3F,MAAM,MAAM,qBAAqB,GAAG;IAClC,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAA;IACZ,kFAAkF;IAClF,UAAU,EAAE,MAAM,CAAA;IAClB,4DAA4D;IAC5D,aAAa,EAAE,OAAO,CAAA;IACtB,oEAAoE;IACpE,aAAa,EAAE,OAAO,CAAA;CACvB,CAAA;AA2hBD,wBAAgB,oBAAoB,CAAC,MAAM,CAAC,EAAE,qBAAqB,GAAG,IAAI,GAAG,MAAM,CAclF;AAED,iFAAiF;AACjF,eAAO,MAAM,qBAAqB,QAA6B,CAAA"}
+{"version":3,"file":"composite.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/composite.ts"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAgC+B;AAC/B;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,EAAE,CAIhG;AAID,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AAEzG,KAAK,qBAAqB,GAAG;IAC3B,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAA;IACZ,kFAAkF;IAClF,UAAU,EAAE,MAAM,CAAA;IAClB,4DAA4D;IAC5D,aAAa,EAAE,OAAO,CAAA;IACtB,oEAAoE;IACpE,aAAa,EAAE,OAAO,CAAA;IACtB,mEAAmE;IACnE,QAAQ,EAAE,MAAM,CAAA;IAChB;mFAC+E;IAC/E,GAAG,CAAC,EAAE,OAAO,CAAA;IACb;;;yEAGqE;IACrE,UAAU,EAAE,MAAM,CAAA;IAClB;;8EAE0E;IAC1E,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;CACjB,CAAA;AA6LD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,kqZA+H5B,CAAA;AA4LD,wBAAgB,oBAAoB,CAAC,MAAM,CAAC,EAAE,qBAAqB,GAAG,IAAI,GAAG,MAAM,CAQlF;AAuDD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,qBAAqB,GAAG,MAAM,CAqEtE;AAED,iFAAiF;AACjF,eAAO,MAAM,qBAAqB,QAA6B,CAAA"}