reze-engine 0.43.0 → 0.50.0

package/dist/shaders/passes/field-blit.js

@@ -0,0 +1,65 @@
+import { sceneFsOutWgsl } from "./scene-contract";
+/**
+ * The field layer, drawn INTO the scene.
+ *
+ * Field effects render into their own targets at their own resolution — that
+ * part was always right. What was wrong was where the result landed: the
+ * composite sampled it AFTER tone mapping, which is why a field effect could
+ * never bloom, could never light anything, and tone mapped differently from the
+ * particle and ribbon mounts drawing the same kind of glow.
+ *
+ * Two draws inside the scene pass — background before any geometry, foreground
+ * after all of it — so the bloom pyramid sees field effects and one tone map
+ * covers the whole frame.
+ *
+ * NO DEPTH, neither written nor tested. A foreground is handed the scene's
+ * depth as a parameter and does its own occlusion; testing it here would
+ * occlude it a second time, and a background has nothing to test against.
+ *
+ * COVERAGE IS CLAMPED HERE. Additive field effects SUM their coverage into the
+ * layer (see FIELD_LAYER_BLEND_ADDITIVE), which is what stops the composite's
+ * unpremultiply from dividing colour by nothing — but N additive effects can
+ * sum past 1, and the layer is rgba16float so nothing stopped it on the way in.
+ * A coverage above 1 would darken what the layer is drawn over by more than
+ * fully covering it.
+ */
+export function fieldBlitShaderWgsl() {
+    return /* wgsl */ `
+@group(0) @binding(0) var _rzLayer: texture_2d<f32>;
+@group(0) @binding(1) var _rzLayerSamp: sampler;
+// (bloom, _, fullW, fullH). The size is the SCENE target's, not the layer's:
+// the layer is often half resolution, and normalised uv is what makes that
+// invisible.
+@group(0) @binding(2) var<uniform> _rzBlitU: vec4f;
+
+@vertex fn vs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {
+  let x = f32((vi & 1u) << 2u) - 1.0;
+  let y = f32((vi & 2u) << 1u) - 1.0;
+  return vec4f(x, y, 0.0, 1.0);
+}
+
+${sceneFsOutWgsl()}
+@fragment fn fs(@builtin(position) fragCoord: vec4f) -> FSOut {
+  var out: FSOut;
+  // Bilinear, because the layer is usually half resolution and the whole point
+  // of that choice is that low-frequency effects upsample invisibly.
+  let uv = fragCoord.xy / max(_rzBlitU.zw, vec2f(1.0));
+  let c = textureSampleLevel(_rzLayer, _rzLayerSamp, uv, 0.0);
+  let cov = clamp(c.a, 0.0, 1.0);
+  // PREMULTIPLIED, and blitted with a premultiplied-over blend — the field
+  // targets have been premultiplied since N effects had to compose into them
+  // associatively. Handing this to the material blend would scale rgb by alpha
+  // a second time and every layer would come out dark.
+  out.color = vec4f(max(c.rgb, vec3f(0.0)), cov);
+  // The aux target: bloom mask, then coverage. THIS is what finally makes
+  // // @bloom mean something on a field effect — the flag has been parsed and
+  // ignored for every mount but particles and ribbons, which is the kind of
+  // author-surface lie the install-time guards exist to kill.
+  //
+  // The mask is written UNWEIGHTED and the blend weights it by src.a — the
+  // convention the materials already follow (they write vec4f(1, 1, 0, alpha)).
+  out.mask = vec4f(_rzBlitU.x, 1.0, 0.0, cov);
+  return out;
+}
+`;
+}

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

@@ -0,0 +1,31 @@
+import { type CastLayout } from "./particles";
+export declare const GRID_MAX = 1024;
+/** rgba16float, ping-ponged. Two of these is the whole memory cost. */
+export declare const SIM_FORMAT: GPUTextureFormat;
+/** `// @grid 256` — the grid's resolution, in texels per side. */
+export declare function parseGridSize(wgsl: string, max: number): number;
+/** Whether this effect drives a grid at all. */
+export declare function gridEntryPoint(wgsl: string): boolean;
+/**
+ * `rzGrid(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 gridReadApi(group: number, tex: number, samp: number, size: number): 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=grid.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grid.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/grid.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAA;AAiC7C,eAAO,MAAM,QAAQ,OAAO,CAAA;AAC5B,uEAAuE;AACvE,eAAO,MAAM,UAAU,EAAE,gBAAgC,CAAA;AAEzD,kEAAkE;AAClE,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAM/D;AAED,gDAAgD;AAChD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CA6B1F;AAWD;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CA6DnF"}

package/dist/shaders/passes/grid.js

@@ -0,0 +1,169 @@
+import { audioApi } from "../audio-api";
+import { lyricsApi } from "../lyrics-api";
+import { anchorAliasWgsl } from "../anchor-table";
+import { midiApi } from "../midi-api";
+import { EFFECT_SCENE_API } from "./composite";
+import { clockApi, trailSlotsApi, viewportApi } from "./hosted-api";
+// 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 GRID_MAX = 1024;
+/** rgba16float, ping-ponged. Two of these is the whole memory cost. */
+export const SIM_FORMAT = "rgba16float";
+/** `// @grid 256` — the grid's resolution, in texels per side. */
+export function parseGridSize(wgsl, max) {
+    const m = /^\s*\/\/\s*@grid\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 gridEntryPoint(wgsl) {
+    return /\bfn\s+gridStep\s*\(/.test(wgsl);
+}
+/**
+ * `rzGrid(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 gridReadApi(group, tex, samp, size) {
+    return /* wgsl */ `
+const RZ_GRID_SIZE: f32 = ${size > 0 ? size : 1}.0;
+@group(${group}) @binding(${tex}) var _rzGridTex: texture_2d<f32>;
+@group(${group}) @binding(${samp}) var _rzGridSamp: 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 rzGrid(uv: vec2f) -> vec4f {
+  return textureSampleLevel(_rzGridTex, _rzGridSamp, clamp(uv, vec2f(0.0), vec2f(1.0)), 0.0);
+}
+fn rzGridSize() -> f32 { return RZ_GRID_SIZE; }
+fn rzGridTexel() -> f32 { return 1.0 / RZ_GRID_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 gridStep 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. rzGridPrev reads the current grid rather than a previous one,
+// which is the honest answer outside the step: there is no previous frame here.
+fn rzGridPrev(uv: vec2f) -> vec4f { return rzGrid(uv); }
+fn rzGridFrame() -> i32 { return 1; }
+`;
+}
+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 _rzGridPrevTex: texture_2d<f32>;
+@group(0) @binding(2) var _rzGridSamp: sampler;
+@group(0) @binding(3) var _rzGridOut: 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>;
+${clockApi("su.time", "su.dt")}${viewportApi("viewU[6].w")}${trailSlotsApi(cast.trailCount)}
+/** Texels per side. */
+fn rzGridSize() -> f32 { return su.size; }
+/** One texel, in uv — the step a neighbour lookup takes. */
+fn rzGridTexel() -> 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 rzGridFrame() -> i32 { return i32(su.frame); }
+
+/** The grid as it was LAST frame, bilinear. The only input a kernel really has. */
+fn rzGridPrev(uv: vec2f) -> vec4f {
+  return textureSampleLevel(_rzGridPrevTex, _rzGridSamp, clamp(uv, vec2f(0.0), vec2f(1.0)), 0.0);
+}
+` +
+        EFFECT_SCENE_API +
+        // The alias _rzSlot, which the scene API's accessors route through. Every
+        // module embedding EFFECT_SCENE_API must splice this; the sim module was
+        // the one that did not, and every gridStep effect failed to install with
+        // "unresolved call target" from the day the identity fallback was removed.
+        // Found by tools/validate-wgsl.mjs on its first run.
+        anchorAliasWgsl(cast.alias) +
+        audioApi(0, 5) +
+        midiApi(0, 7) +
+        lyricsApi(0, 8) +
+        // rzGrid 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 rzGrid(uv: vec2f) -> vec4f { return rzGridPrev(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 rzGridPrev
+  // lands on itself rather than a quarter-texel off.
+  let uv = (vec2f(f32(gid.x), f32(gid.y)) + vec2f(0.5)) / su.size;
+  textureStore(_rzGridOut, xy, gridStep(uv, textureLoad(_rzGridPrevTex, xy, 0), su.dt));
+}
+`);
+}

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

@@ -1,2 +1,14 @@
-export declare const GROUND_SHADOW_SHADER_WGSL = "\nstruct CameraUniforms { view: mat4x4f, projection: mat4x4f, viewPos: vec3f, _p: f32, };\nstruct Light { direction: vec4f, color: vec4f, };\nstruct LightUniforms { ambientColor: vec4f, lights: array<Light, 4>, };\nstruct GroundShadowMat {\n  diffuseColor: vec3f, fadeStart: f32,\n  fadeEnd: f32, shadowStrength: f32, pcfTexel: f32, gridSpacing: f32,\n  gridLineWidth: f32, gridLineOpacity: f32, noiseStrength: f32, opacity: f32,\n  gridLineColor: vec3f, _pad2: f32,\n};\nstruct LightVP { viewProj: mat4x4f, };\n@group(0) @binding(0) var<uniform> camera: CameraUniforms;\n@group(0) @binding(1) var<uniform> light: LightUniforms;\n@group(0) @binding(2) var shadowMap: texture_depth_2d;\n@group(0) @binding(3) var shadowSampler: sampler_comparison;\n@group(0) @binding(4) var<uniform> material: GroundShadowMat;\n@group(0) @binding(5) var<uniform> lightVP: LightVP;\n\nfn hash2(p: vec2f) -> f32 {\n  var p3 = fract(vec3f(p.x, p.y, p.x) * 0.1031);\n  p3 += dot(p3, vec3f(p3.y + 33.33, p3.z + 33.33, p3.x + 33.33));\n  return fract((p3.x + p3.y) * p3.z);\n}\nfn valueNoise(p: vec2f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  return mix(mix(hash2(i), hash2(i + vec2f(1.0, 0.0)), u.x),\n             mix(hash2(i + vec2f(0.0, 1.0)), hash2(i + vec2f(1.0, 1.0)), u.x), u.y);\n}\nfn fbmNoise(p: vec2f) -> f32 {\n  var v = 0.0;\n  var a = 0.5;\n  var pp = p;\n  for (var i = 0; i < 4; i++) {\n    v += a * valueNoise(pp);\n    pp *= 2.0;\n    a *= 0.5;\n  }\n  return v;\n}\n\nstruct VO { @builtin(position) position: vec4f, @location(0) worldPos: vec3f, @location(1) normal: vec3f, };\n@vertex fn vs(@location(0) position: vec3f, @location(1) normal: vec3f, @location(2) uv: vec2f) -> VO {\n  var o: VO; o.worldPos = position; o.normal = normal;\n  o.position = camera.projection * camera.view * vec4f(position, 1.0); return o;\n}\nstruct FSOut { @location(0) color: vec4f, @location(1) mask: vec4f };\n@fragment fn fs(i: VO) -> FSOut {\n  // Derivatives first, unconditionally: WGSL requires fwidth in uniform control\n  // flow and everything below branches on world position.\n  let gp = i.worldPos.xz / material.gridSpacing;\n  let gridDeriv = fwidth(gp);\n\n  var out: FSOut;\n  let n = normalize(i.normal);\n  let centerDist = length(i.worldPos.xz);\n  let edgeFade = 1.0 - smoothstep(0.0, 1.0, clamp((centerDist - material.fadeStart) / max(material.fadeEnd - material.fadeStart, 0.001), 0.0, 1.0));\n\n  // Past the radial fade every term below is multiplied by edgeFade and the\n  // pixel is fully transparent. Shading it anyway produces nothing.\n  if (edgeFade <= 0.0) {\n    out.color = vec4f(0.0);\n    out.mask = vec4f(0.0, 1.0, 0.0, 0.0);\n    return out;\n  }\n\n  let lclip = lightVP.viewProj * vec4f(i.worldPos, 1.0);\n  let ndc = lclip.xyz / max(lclip.w, 1e-6);\n  // Outside the light's frustum there IS no shadow information \u2014 the clamped\n  // border samples compare against unrelated depths and read \"shadowed\",\n  // darkening the whole far plane with a visible band at the frustum edge\n  // (masked by the opaque surface normally, glaring in green-screen mode where\n  // only the shadow-catcher term renders). Fade to fully lit near the border.\n  let inZ = select(0.0, 1.0, ndc.z > 0.0 && ndc.z < 1.0);\n  let frustum = (1.0 - smoothstep(0.88, 0.96, abs(ndc.x))) * (1.0 - smoothstep(0.88, 0.96, abs(ndc.y))) * inZ;\n\n  // THE cost of this shader, measured: a full-screen ground ran 25 shadow\n  // comparisons per pixel, and each one is hardware-bilinear, so ~100 depth\n  // samples per pixel. Gutting the rest of the shader changed nothing; cutting\n  // this is what makes looking down cheap.\n  //\n  // 3x3 at two-texel spacing covers the same +/-2 texel penumbra the 5x5 at\n  // one-texel spacing did \u2014 that kernel was oversampled, its taps overlapping\n  // almost entirely once the comparison sampler's own 2x2 filter is counted.\n  // Nine taps instead of twenty-five for the same blur radius.\n  //\n  // Skipped altogether outside the light frustum, where the mix below discards\n  // the result anyway: the shadow map covers a small area around the character\n  // and the ground is vastly larger than it.\n  var vis = 1.0;\n  if (frustum > 0.0) {\n    let suv = vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);\n    let suv_c = clamp(suv, vec2f(0.02), vec2f(0.98));\n    let st = material.pcfTexel * 2.0;\n    let compareZ = ndc.z - 0.0035;\n    var acc = 0.0;\n    for (var y = -1; y <= 1; y++) {\n      for (var x = -1; x <= 1; x++) {\n        // ...Level, not the implicit-derivative form: identical on a single-mip\n        // shadow map, and legal inside this branch.\n        acc += textureSampleCompareLevel(shadowMap, shadowSampler, suv_c + vec2f(f32(x), f32(y)) * st, compareZ);\n      }\n    }\n    vis = mix(1.0, acc * (1.0 / 9.0), frustum);\n  }\n\n  // Frosted/matte micro-texture. Scenes leaving it at zero were still paying\n  // sixteen hash rounds a pixel for a tint of exactly 1.\n  var noiseTint = 1.0;\n  if (material.noiseStrength != 0.0) {\n    let noiseVal = fbmNoise(i.worldPos.xz * 3.0);\n    noiseTint = 1.0 + (noiseVal - 0.5) * material.noiseStrength;\n  }\n\n  // Grid lines \u2014 anti-aliased via screen-space derivatives\n  let gridFrac = abs(fract(gp - 0.5) - 0.5);\n  let halfLine = material.gridLineWidth * 0.5;\n  let gridLine = 1.0 - min(\n    smoothstep(halfLine - gridDeriv.x, halfLine + gridDeriv.x, gridFrac.x),\n    smoothstep(halfLine - gridDeriv.y, halfLine + gridDeriv.y, gridFrac.y)\n  );\n  let sun = light.ambientColor.xyz + light.lights[0].color.xyz * light.lights[0].color.w * max(dot(n, -light.lights[0].direction.xyz), 0.0);\n  let dark = (1.0 - vis) * material.shadowStrength;\n  var baseColor = material.diffuseColor * sun * (1.0 - dark * 0.65);\n  baseColor *= noiseTint;\n  let finalColor = mix(baseColor, material.gridLineColor, gridLine * material.gridLineOpacity * edgeFade);\n  // Whole-ground opacity fades the SURFACE (color, grid) but the shadow stays \u2014\n  // as opacity drops, the received shadow becomes a translucent dark layer\n  // (Blender's Shadow Catcher), so models still feel grounded on a photo or\n  // 360 backdrop. At opacity 1 this reduces exactly to the plain surface.\n  let surfA = edgeFade * material.opacity;\n  let catchA = dark * 0.65 * edgeFade * (1.0 - material.opacity);\n  let outA = surfA + catchA;\n  out.color = vec4f(finalColor * surfA, outA);\n  // mask.r = 0: ground never contributes to bloom. mask.g = 1.0 with src.a =\n  // outA turns the aux blend into alpha-over, so the drawable alpha goes\n  // from outA at the center to 0 at the radial edge \u2014 letting the page\n  // background show through under the premultiplied canvas alphaMode.\n  out.mask = vec4f(0.0, 1.0, 0.0, outA);\n  return out;\n}\n";
+export declare function groundShaderWgsl(): string;
+/**
+ * The ground belongs to no model instance, so it takes ids of its own — at the
+ * TOP of the u16 range, not at the bottom.
+ *
+ * Both of the engine's counters are 1-based (model id is instance count + 1,
+ * material id counts from one), so 1 is the first model's first material and
+ * the floor would have shared it. 0 stays unclaimed in the other direction: it
+ * is what the attachment clears to, and so what every pixel nothing drew
+ * reports.
+ */
+export declare const GROUND_MATERIAL_ID = 65535;
+export declare const GROUND_OBJECT_ID = 65535;
 //# sourceMappingURL=ground.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ground.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/ground.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,yBAAyB,gpNA8IrC,CAAA"}
+{"version":3,"file":"ground.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/ground.ts"],"names":[],"mappings":"AAYA,wBAAgB,gBAAgB,IAAI,MAAM,CA2QzC;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,QAAS,CAAA;AACxC,eAAO,MAAM,gBAAgB,QAAS,CAAA"}

package/dist/shaders/passes/ground.js

@@ -1,22 +1,47 @@
+import { sceneFsOutWgsl, sceneIdWriteWgsl } from "./scene-contract";
+import { lightsApi } from "../lights";
+import { SHADOW_CASCADES } from "../../shadow-cascades";
+import { WORLD_AMBIENT_WGSL } from "../lights";
 // Ground shadow-catcher: receives directional shadow, grid lines, frosted noise,
 // radial distance fade. Writes bloom mask = 0 (ground never bloom-bleeds).
-export const GROUND_SHADOW_SHADER_WGSL = /* wgsl */ `
+//
+// A FUNCTION, not a constant, since the id attachment is a device capability:
+// the struct this returns depends on what the probe at init found, and a string
+// baked at import time cannot know that. Called once, when the module is built.
+export function groundShaderWgsl() {
+    return /* wgsl */ `
 struct CameraUniforms { view: mat4x4f, projection: mat4x4f, viewPos: vec3f, _p: f32, };
 struct Light { direction: vec4f, color: vec4f, };
-struct LightUniforms { ambientColor: vec4f, lights: array<Light, 4>, };
+struct LightUniforms { ambientColor: vec4f, lights: array<Light, 4>, sh: array<vec4f, 9>, };
 struct GroundShadowMat {
   diffuseColor: vec3f, fadeStart: f32,
   fadeEnd: f32, shadowStrength: f32, pcfTexel: f32, gridSpacing: f32,
   gridLineWidth: f32, gridLineOpacity: f32, noiseStrength: f32, opacity: f32,
-  gridLineColor: vec3f, _pad2: f32,
+  gridLineColor: vec3f, mirror: f32,
+  mirrorBlur: f32, _mb0: f32, _mb1: f32, _mb2: f32,
 };
-struct LightVP { viewProj: mat4x4f, };
+// One view-projection per shadow cascade, inner to outer — same buffer and
+// same order the materials read.
+struct LightVP { viewProj: array<mat4x4f, ${SHADOW_CASCADES.length}>, };
 @group(0) @binding(0) var<uniform> camera: CameraUniforms;
 @group(0) @binding(1) var<uniform> light: LightUniforms;
 @group(0) @binding(2) var shadowMap: texture_depth_2d;
 @group(0) @binding(3) var shadowSampler: sampler_comparison;
 @group(0) @binding(4) var<uniform> material: GroundShadowMat;
 @group(0) @binding(5) var<uniform> lightVP: LightVP;
+// The far cascade's map, binding 7 as in the materials' layout.
+@group(0) @binding(7) var shadowMapFar: texture_depth_2d;
+// The floor mirror (step 7D): the reflection target, the camera that rendered
+// it, and an ordinary sampler — the two shadow bindings above are comparison.
+// params = (projA, projB, _, _) — the depth-linearisation pair of the SHARED
+// projection, refreshed per frame beside the matrix.
+struct MirrorVP { viewProj: mat4x4f, params: vec4f, };
+@group(0) @binding(8) var<uniform> mirrorVP: MirrorVP;
+@group(0) @binding(9) var mirrorTex: texture_2d<f32>;
+@group(0) @binding(10) var linearSampler: sampler;
+@group(0) @binding(11) var mirrorDepth: texture_depth_multisampled_2d;
+${WORLD_AMBIENT_WGSL}
+${lightsApi(0, 6)}
 
 fn hash2(p: vec2f) -> f32 {
   var p3 = fract(vec3f(p.x, p.y, p.x) * 0.1031);
@@ -47,8 +72,7 @@ struct VO { @builtin(position) position: vec4f, @location(0) worldPos: vec3f, @l
   var o: VO; o.worldPos = position; o.normal = normal;
   o.position = camera.projection * camera.view * vec4f(position, 1.0); return o;
 }
-struct FSOut { @location(0) color: vec4f, @location(1) mask: vec4f };
-@fragment fn fs(i: VO) -> FSOut {
+${sceneFsOutWgsl()}@fragment fn fs(i: VO) -> FSOut {
   // Derivatives first, unconditionally: WGSL requires fwidth in uniform control
   // flow and everything below branches on world position.
   let gp = i.worldPos.xz / material.gridSpacing;
@@ -67,15 +91,20 @@ struct FSOut { @location(0) color: vec4f, @location(1) mask: vec4f };
     return out;
   }
 
-  let lclip = lightVP.viewProj * vec4f(i.worldPos, 1.0);
-  let ndc = lclip.xyz / max(lclip.w, 1e-6);
-  // Outside the light's frustum there IS no shadow information — the clamped
+  // Outside a cascade's frustum there IS no shadow information — the clamped
   // border samples compare against unrelated depths and read "shadowed",
   // darkening the whole far plane with a visible band at the frustum edge
   // (masked by the opaque surface normally, glaring in green-screen mode where
-  // only the shadow-catcher term renders). Fade to fully lit near the border.
+  // only the shadow-catcher term renders). So each cascade fades out near its
+  // border — the near one INTO the far one's answer, the far one into lit.
+  let l0 = lightVP.viewProj[0] * vec4f(i.worldPos, 1.0);
+  let ndc = l0.xyz / max(l0.w, 1e-6);
   let inZ = select(0.0, 1.0, ndc.z > 0.0 && ndc.z < 1.0);
   let frustum = (1.0 - smoothstep(0.88, 0.96, abs(ndc.x))) * (1.0 - smoothstep(0.88, 0.96, abs(ndc.y))) * inZ;
+  let l1 = lightVP.viewProj[1] * vec4f(i.worldPos, 1.0);
+  let ndc1 = l1.xyz / max(l1.w, 1e-6);
+  let inZ1 = select(0.0, 1.0, ndc1.z > 0.0 && ndc1.z < 1.0);
+  let frustum1 = (1.0 - smoothstep(0.88, 0.96, abs(ndc1.x))) * (1.0 - smoothstep(0.88, 0.96, abs(ndc1.y))) * inZ1;
 
   // THE cost of this shader, measured: a full-screen ground ran 25 shadow
   // comparisons per pixel, and each one is hardware-bilinear, so ~100 depth
@@ -87,10 +116,23 @@ struct FSOut { @location(0) color: vec4f, @location(1) mask: vec4f };
   // almost entirely once the comparison sampler's own 2x2 filter is counted.
   // Nine taps instead of twenty-five for the same blur radius.
   //
-  // Skipped altogether outside the light frustum, where the mix below discards
-  // the result anyway: the shadow map covers a small area around the character
-  // and the ground is vastly larger than it.
+  // The far cascade's taps run ONLY where the near one is fading or absent
+  // (frustum < 1), so a pixel in the near core costs exactly what it did with
+  // one cascade — and that core is where the camera usually looks.
   var vis = 1.0;
+  if (frustum < 1.0 && frustum1 > 0.0) {
+    let suv1 = vec2f(ndc1.x * 0.5 + 0.5, 0.5 - ndc1.y * 0.5);
+    let suv1_c = clamp(suv1, vec2f(0.02), vec2f(0.98));
+    let st1 = ${1 / SHADOW_CASCADES[SHADOW_CASCADES.length - 1].mapSize} * 2.0;
+    let compareZ1 = ndc1.z - 0.0035;
+    var acc1 = 0.0;
+    for (var y = -1; y <= 1; y++) {
+      for (var x = -1; x <= 1; x++) {
+        acc1 += textureSampleCompareLevel(shadowMapFar, shadowSampler, suv1_c + vec2f(f32(x), f32(y)) * st1, compareZ1);
+      }
+    }
+    vis = mix(1.0, acc1 * (1.0 / 9.0), frustum1);
+  }
   if (frustum > 0.0) {
     let suv = vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);
     let suv_c = clamp(suv, vec2f(0.02), vec2f(0.98));
@@ -104,7 +146,9 @@ struct FSOut { @location(0) color: vec4f, @location(1) mask: vec4f };
         acc += textureSampleCompareLevel(shadowMap, shadowSampler, suv_c + vec2f(f32(x), f32(y)) * st, compareZ);
       }
     }
-    vis = mix(1.0, acc * (1.0 / 9.0), frustum);
+    // The base is whatever the far cascade decided, so the near border blends
+    // cascade to cascade rather than snapping to lit mid-floor.
+    vis = mix(vis, acc * (1.0 / 9.0), frustum);
   }
 
   // Frosted/matte micro-texture. Scenes leaving it at zero were still paying
@@ -122,24 +166,125 @@ struct FSOut { @location(0) color: vec4f, @location(1) mask: vec4f };
     smoothstep(halfLine - gridDeriv.x, halfLine + gridDeriv.x, gridFrac.x),
     smoothstep(halfLine - gridDeriv.y, halfLine + gridDeriv.y, gridFrac.y)
   );
-  let sun = light.ambientColor.xyz + light.lights[0].color.xyz * light.lights[0].color.w * max(dot(n, -light.lights[0].direction.xyz), 0.0);
+  let sun = rzWorldAmbient(n) + light.lights[0].color.xyz * light.lights[0].color.w * max(dot(n, -light.lights[0].direction.xyz), 0.0);
+  // The positional layer reaches the floor too. A stage light that lit the
+  // cast and not the ground under her would read as a sticker, which is the
+  // same failure the shadow catcher exists to prevent.
+  let lamps = rzLightsDiffuse(i.worldPos, n);
   let dark = (1.0 - vis) * material.shadowStrength;
-  var baseColor = material.diffuseColor * sun * (1.0 - dark * 0.65);
+  // The shadow darkens the SUN only. The dark term comes from the sun's shadow
+  // map, so applying it to the lamps too would have a lamp on the far side of
+  // the stage dimmed by a shadow cast away from it — the one light in the scene
+  // that provably is not blocking it.
+  // (No backticks in here: this string is a TS template literal and one ends it
+  // mid-shader, which is exactly how this line broke the build a moment ago.)
+  var baseColor = material.diffuseColor * (sun * (1.0 - dark * 0.65) + lamps);
   baseColor *= noiseTint;
-  let finalColor = mix(baseColor, material.gridLineColor, gridLine * material.gridLineOpacity * edgeFade);
-  // Whole-ground opacity fades the SURFACE (color, grid) but the shadow stays —
-  // as opacity drops, the received shadow becomes a translucent dark layer
-  // (Blender's Shadow Catcher), so models still feel grounded on a photo or
-  // 360 backdrop. At opacity 1 this reduces exactly to the plain surface.
+  // The floor mirror — its OWN LAYER, not a blend into the surface. The
+  // reflection was rendered by the MIRROR camera, so projecting this
+  // fragment's world position through that camera yields exactly the texel
+  // where its reflection landed — projective mapping, no screen-space guess.
+  // There is deliberately NO strength dial: mirror is on or off, and how much
+  // of it shows is the SURFACE's own opacity covering it — the same
+  // independence the grid won earlier. The branch is on a uniform, so the
+  // whole cost vanishes for the scenes that leave it off.
+  var reflShadowed = vec3f(0.0);
+  if (material.mirror > 0.0) {
+    let mc = mirrorVP.viewProj * vec4f(i.worldPos, 1.0);
+    let mndc = mc.xyz / max(mc.w, 1e-6);
+    let muv = clamp(vec2f(mndc.x * 0.5 + 0.5, 0.5 - mndc.y * 0.5), vec2f(0.0), vec2f(1.0));
+    var lod = 0.0;
+    if (material.mirrorBlur > 0.0) {
+      // DEPTH-PROPORTIONAL softness: the real driver is how far BEHIND the
+      // mirror surface the reflected geometry sits — a foot on the floor
+      // reflects sharp, a head reflects soft, the empty backdrop softest.
+      //
+      // Read the mirror pass's own depth at this texel, linearise it with the
+      // shared projection's pair (viewZ = projB / (z - projA); the formula
+      // inverts both depth conventions, see the composite's linearDepth), and
+      // reconstruct the reflected image point along the ray from the MIRRORED
+      // eye through this fragment. The plane is y = 0, so mirroring the eye
+      // and the camera forward is a sign flip on y, and the image point's
+      // depth below the plane IS the reflected object's height above it.
+      let dims = vec2f(textureDimensions(mirrorDepth));
+      let texel = clamp(vec2i(muv * dims), vec2i(0), vec2i(dims) - vec2i(1));
+      let z = textureLoad(mirrorDepth, texel, 0);
+      let viewZ = clamp(mirrorVP.params.y / (z - mirrorVP.params.x), 0.05, 100000.0);
+      let eyeM = vec3f(camera.viewPos.x, -camera.viewPos.y, camera.viewPos.z);
+      let fwd = vec3f(camera.view[0][2], camera.view[1][2], camera.view[2][2]);
+      let fwdM = vec3f(fwd.x, -fwd.y, fwd.z);
+      let toFrag = i.worldPos - eyeM;
+      let dir = toFrag * inverseSqrt(max(dot(toFrag, toFrag), 1e-8));
+      let t = viewZ / max(dot(dir, fwdM), 1e-4);
+      let height = max(-(eyeM.y + dir.y * t), 0.0);
+      // Full softness by BLUR_SPAN units above the floor — about a character's
+      // height. The hardware clamps the level, so the nominal 5.0 needs no
+      // knowledge of the real chain length, and blur 0 reads exactly level 0.
+      let BLUR_SPAN = 14.0;
+      lod = material.mirrorBlur * 5.0 * clamp(height / BLUR_SPAN, 0.0, 1.0);
+    }
+    let refl = textureSampleLevel(mirrorTex, linearSampler, muv, lod).rgb;
+    // Still under the received shadow: a polished floor in shade shows a dim
+    // reflection, and a mirror that ignored the shadow would glow in it.
+    reflShadowed = refl * (1.0 - dark * 0.65);
+  }
+  // THREE LAYERS, composited premultiplied, bottom to top: the shadow the
+  // catcher receives, the ground surface, and the grid.
+  //
+  // The grid used to be MIXED INTO the surface and then weighted by the
+  // surface's own alpha, so turning the ground down to nothing took the grid
+  // with it — you could not have a bare grid over a photo, which is most of
+  // what a grid is for. It is its own layer now: the ground plane keeps an
+  // alpha, and the grid is simply on or off.
   let surfA = edgeFade * material.opacity;
-  let catchA = dark * 0.65 * edgeFade * (1.0 - material.opacity);
-  let outA = surfA + catchA;
-  out.color = vec4f(finalColor * surfA, outA);
+  let gridA = gridLine * material.gridLineOpacity * edgeFade;
+  // The mirror is opaque across the ground's extent when on — it always shows
+  // SOMETHING, because the backdrop rides in the reflection target itself.
+  let mirrA = material.mirror * edgeFade;
+  // As opacity drops the received shadow becomes a translucent dark layer
+  // (Blender's Shadow Catcher), so models still feel grounded on a photo or a
+  // 360 backdrop. Colourless by construction: it darkens by covering. The
+  // MIRROR subsumes it: the reflection already carries the received shadow,
+  // and a catcher stacked on top would darken the same shadow twice.
+  let catchA = dark * 0.65 * edgeFade * (1.0 - material.opacity) * (1.0 - material.mirror);
+
+  // FOUR LAYERS, premultiplied, bottom to top: reflection, received shadow,
+  // ground surface, grid. Each with its own coverage, none scaling another —
+  // ground opacity REVEALS the mirror rather than the mirror carrying a
+  // strength of its own.
+  var pm = reflShadowed * mirrA;
+  var cov = mirrA;
+  // Shadow catcher over the reflection-or-nothing: black, it covers.
+  pm = pm * (1.0 - catchA);
+  cov = catchA + cov * (1.0 - catchA);
+  // Surface over shadow.
+  pm = baseColor * surfA + pm * (1.0 - surfA);
+  cov = surfA + cov * (1.0 - surfA);
+  // Grid over surface. Unshadowed, as it has always been — a painted line reads
+  // as paint, and darkening it was never what the mix did either.
+  pm = material.gridLineColor * gridA + pm * (1.0 - gridA);
+  cov = gridA + cov * (1.0 - gridA);
+
+  let outA = cov;
+  out.color = vec4f(pm, outA);
   // mask.r = 0: ground never contributes to bloom. mask.g = 1.0 with src.a =
   // outA turns the aux blend into alpha-over, so the drawable alpha goes
   // from outA at the center to 0 at the radial edge — letting the page
   // background show through under the premultiplied canvas alphaMode.
   out.mask = vec4f(0.0, 1.0, 0.0, outA);
-  return out;
+${sceneIdWriteWgsl("out", `${GROUND_MATERIAL_ID}u`, `${GROUND_OBJECT_ID}u`)}  return out;
 }
 `;
+}
+/**
+ * The ground belongs to no model instance, so it takes ids of its own — at the
+ * TOP of the u16 range, not at the bottom.
+ *
+ * Both of the engine's counters are 1-based (model id is instance count + 1,
+ * material id counts from one), so 1 is the first model's first material and
+ * the floor would have shared it. 0 stays unclaimed in the other direction: it
+ * is what the attachment clears to, and so what every pixel nothing drew
+ * reports.
+ */
+export const GROUND_MATERIAL_ID = 0xffff;
+export const GROUND_OBJECT_ID = 0xffff;

package/dist/shaders/passes/hosted-api.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The particle record, laid out by hand — declared in EVERY hosting module.
+ *
+ * Not only in the particle ones: `fn particleStep(p: Particle)` is part of the
+ * author's file, so the trail, field and lightEmit modules compile that
+ * signature as dead code and a missing struct is a compile error on a function
+ * the author was right to write. The trail module used to carry a hand-copied
+ * duplicate for exactly this reason.
+ *
+ * `age` and `life` sit in the padding that vec3f alignment would waste anyway
+ * (a vec3f occupies 12 bytes but aligns the next field to 16), so the struct is
+ * 48 bytes rather than the 64 a naive ordering costs. At 4096 particles that is
+ * 192KB instead of 256KB, and it is read every frame by both stages.
+ *
+ * `life <= 0` means "not alive" and is what the pool checks to recycle a slot,
+ * so a freshly zeroed buffer is entirely dead and every particle is born on the
+ * first step rather than needing a separate seeding pass.
+ *
+ * RzLight is the same kind of thing and lives in lights.ts, because it is that
+ * module's own type; every hosting module splices it for this same reason.
+ */
+export declare const PARTICLE_STRUCT_WGSL = "\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";
+/**
+ * `rzTime`/`rzDt`, from whatever the module calls its clock.
+ *
+ * A module with no clock of its own passes a literal. Zero dt is honest there:
+ * nothing spliced into it is being stepped, so a kernel that integrates would
+ * integrate by nothing rather than by a plausible-looking wrong number.
+ */
+export declare function clockApi(timeExpr: string, dtExpr: string): string;
+/** `rzViewportHeight` — the render target's height in pixels, which is what a
+ *  point size in world units has to be divided by to become a pixel radius. */
+export declare function viewportApi(heightExpr: string): string;
+/**
+ * The one cast number that is PER EFFECT rather than per engine.
+ *
+ * Author-visible, and published effects loop over it, so its meaning is pinned:
+ * how many of THIS effect's anchors asked for a trail. Deliberately not the
+ * anchor address space — that is RZ_MAX_ANCHORS in CAST_API, and the two being
+ * one number was the old trail bug. Everything else about the cast's shape is a
+ * constant and lives there.
+ */
+export declare function trailSlotsApi(trailCount: number): string;
+/**
+ * Pure math — no bindings, no uniforms, identical in every module.
+ *
+ * These were duplicated in the particle and trail modules, byte for byte in the
+ * case of rzFalloff and to a `+ vec3f(0.0)` in the case of rzValueNoise. Two
+ * copies of a noise function is one bad merge away from an effect that looks
+ * different depending on which mount drew it, which is not a bug anyone would
+ * think to look for.
+ *
+ * EVERY hosting module includes this and none defines any of these itself, so
+ * "which module am I in" can never change what a helper returns.
+ */
+export declare const EFFECT_MATH_API = "\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";
+//# sourceMappingURL=hosted-api.d.ts.map

package/dist/shaders/passes/hosted-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hosted-api.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/hosted-api.ts"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,oBAAoB,+UAchC,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAKjE;AAED;+EAC+E;AAC/E,wBAAgB,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAItD;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAIxD;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,ixEA6D3B,CAAA"}