reze-engine 0.50.3 → 0.50.4

package/dist/shaders/passes/field-blit.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 declare function fieldBlitShaderWgsl(): string;
+//# sourceMappingURL=field-blit.d.ts.map

package/dist/shaders/passes/field-blit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-blit.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/field-blit.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAuC5C"}

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/ground-noise.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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 declare function buildGroundNoiseMips(): Uint8Array[];
+//# sourceMappingURL=ground-noise.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ground-noise.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/ground-noise.ts"],"names":[],"mappings":"AAkDA;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,UAAU,EAAE,CAsCnD"}

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

@@ -0,0 +1,88 @@
+// 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/ground.d.ts

@@ -11,4 +11,20 @@ export declare function groundShaderWgsl(): string;
  */
 export declare const GROUND_MATERIAL_ID = 65535;
 export declare const GROUND_OBJECT_ID = 65535;
+/** Texel edge of the baked frost tile. 1024 over a 64-p-unit period is two
+ *  texels per finest-octave noise cell — the bake resolves everything the
+ *  evaluation produced. r8unorm: the value lives in [0,1] and feeds a 0.05
+ *  tint; eight bits is already 5x below what that tint can show. */
+export declare const GROUND_NOISE_SIZE = 1024;
+/**
+ * The frost fbm as a bake: identical math, periodic lattice.
+ *
+ * hash2/valueNoise/fbm are the ground's old helpers verbatim, with one change —
+ * each octave's lattice wraps at its own period (64 p-units at octave 0,
+ * doubling with frequency), so the tile is seamless under the repeat sampler.
+ * Wrapping only renames lattice cells on the seam; every interior cell hashes
+ * exactly as before, which is what makes the bake a relocation of the old
+ * pixels rather than a new look.
+ */
+export declare const GROUND_NOISE_BAKE_WGSL = "\n@vertex fn vs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {\n  let x = f32((vi & 1u) << 2u) - 1.0;\n  let y = f32((vi & 2u) << 1u) - 1.0;\n  return vec4f(x, y, 0.0, 1.0);\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 wrapCell(i: vec2f, period: f32) -> vec2f { return i - period * floor(i / period); }\nfn valueNoiseP(p: vec2f, period: f32) -> 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(wrapCell(i, period)), hash2(wrapCell(i + vec2f(1.0, 0.0), period)), u.x),\n             mix(hash2(wrapCell(i + vec2f(0.0, 1.0), period)), hash2(wrapCell(i + vec2f(1.0, 1.0), period)), u.x), u.y);\n}\n@fragment fn fs(@builtin(position) pos: vec4f) -> @location(0) vec4f {\n  let p = pos.xy * (64.0 / 1024.0);\n  var v = 0.0;\n  var a = 0.5;\n  var pp = p;\n  var period = 64.0;\n  for (var o = 0; o < 4; o++) {\n    v += a * valueNoiseP(pp, period);\n    pp *= 2.0;\n    period *= 2.0;\n    a *= 0.5;\n  }\n  return vec4f(v, 0.0, 0.0, 1.0);\n}\n";
 //# 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":"AAYA,wBAAgB,gBAAgB,IAAI,MAAM,CA2QzC;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,QAAS,CAAA;AACxC,eAAO,MAAM,gBAAgB,QAAS,CAAA"}
+{"version":3,"file":"ground.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/ground.ts"],"names":[],"mappings":"AAYA,wBAAgB,gBAAgB,IAAI,MAAM,CAkUzC;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,QAAS,CAAA;AACxC,eAAO,MAAM,gBAAgB,QAAS,CAAA;AAEtC;;;oEAGoE;AACpE,eAAO,MAAM,iBAAiB,OAAO,CAAA;AAErC;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,+oCAiClC,CAAA"}

package/dist/shaders/passes/ground.js

@@ -18,7 +18,13 @@ struct GroundShadowMat {
   fadeEnd: f32, shadowStrength: f32, pcfTexel: f32, gridSpacing: f32,
   gridLineWidth: f32, gridLineOpacity: f32, noiseStrength: f32, opacity: f32,
   gridLineColor: vec3f, mirror: f32,
-  mirrorBlur: f32, _mb0: f32, _mb1: f32, _mb2: f32,
+  // farCascade: 1 while a stage is loaded, 0 otherwise. See the branch below —
+  // with no stage the far map is never drawn into, so its taps are known.
+  mirrorBlur: f32, farCascade: f32, _mb1: f32, _mb2: f32,
+  // Every shadow caster in one sphere, refreshed per frame. w = radius; 0 means
+  // nothing casts, negative means "do not use this" (a rigid caster has no
+  // sphere, so a scene with a stage keeps the taps). See rzShadowPossible.
+  casterSphere: vec4f,
 };
 // One view-projection per shadow cascade, inner to outer — same buffer and
 // same order the materials read.
@@ -40,33 +46,12 @@ struct MirrorVP { viewProj: mat4x4f, params: vec4f, };
 @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;
+// The frost noise, PRE-BAKED — see GROUND_NOISE_BAKE_WGSL below. Sampled with
+// the repeat sampler already at binding 10.
+@group(0) @binding(12) var noiseTex: texture_2d<f32>;
 ${WORLD_AMBIENT_WGSL}
 ${lightsApi(0, 6)}
 
-fn hash2(p: vec2f) -> f32 {
-  var p3 = fract(vec3f(p.x, p.y, p.x) * 0.1031);
-  p3 += dot(p3, vec3f(p3.y + 33.33, p3.z + 33.33, p3.x + 33.33));
-  return fract((p3.x + p3.y) * p3.z);
-}
-fn valueNoise(p: vec2f) -> f32 {
-  let i = floor(p);
-  let f = fract(p);
-  let u = f * f * (3.0 - 2.0 * f);
-  return mix(mix(hash2(i), hash2(i + vec2f(1.0, 0.0)), u.x),
-             mix(hash2(i + vec2f(0.0, 1.0)), hash2(i + vec2f(1.0, 1.0)), u.x), u.y);
-}
-fn fbmNoise(p: vec2f) -> f32 {
-  var v = 0.0;
-  var a = 0.5;
-  var pp = p;
-  for (var i = 0; i < 4; i++) {
-    v += a * valueNoise(pp);
-    pp *= 2.0;
-    a *= 0.5;
-  }
-  return v;
-}
-
 struct VO { @builtin(position) position: vec4f, @location(0) worldPos: vec3f, @location(1) normal: vec3f, };
 @vertex fn vs(@location(0) position: vec3f, @location(1) normal: vec3f, @location(2) uv: vec2f) -> VO {
   var o: VO; o.worldPos = position; o.normal = normal;
@@ -119,8 +104,63 @@ ${sceneFsOutWgsl()}@fragment fn fs(i: VO) -> FSOut {
   // 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.
+  // Can anything cast a shadow ONTO this point at all?
+  //
+  // The ground is vastly larger than what stands on it, and the answer for most
+  // of it is no. A point is shadowed only if the ray from it toward the light
+  // meets a caster, so testing that ray against one bounding sphere decides in a
+  // few ALU ops what nine hardware-bilinear depth comparisons would otherwise be
+  // spent discovering. Same pixels: outside the sphere vis stays 1.0, which is
+  // exactly what the taps return.
+  //
+  // Conservative in all three directions that matter. The sphere is a union of
+  // per-model bounds built from POSED bones plus the skin margin, so a jump or a
+  // flying skirt is inside it. A negative radius disables the test outright. And
+  // the halfspace check uses -R rather than 0, so a caster the point is standing
+  // inside still counts.
+  var shadowPossible = material.casterSphere.w > 0.0;
+  if (shadowPossible) {
+    let toLight = normalize(-light.lights[0].direction.xyz);
+    let toCaster = material.casterSphere.xyz - i.worldPos;
+    let along = dot(toCaster, toLight);
+    let perp = length(toCaster - toLight * along);
+    shadowPossible = along > -material.casterSphere.w && perp <= material.casterSphere.w;
+  } else {
+    // Negative radius is the opt-out, not "nothing casts".
+    shadowPossible = material.casterSphere.w < 0.0;
+  }
+
   var vis = 1.0;
-  if (frustum < 1.0 && frustum1 > 0.0) {
+  // The whole cascade lookup, behind the strength dial.
+  //
+  // This is a FULL-COVERAGE draw and each branch below is nine comparison-sampler
+  // taps per pixel — eighteen where the cascades overlap — so on a retina canvas
+  // it is tens of millions of shadow-map fetches a frame. All of it was computed
+  // and then multiplied by material.shadowStrength, which is ZERO whenever the
+  // host turns the ground's shadow catcher off. Turning shadows off in the UI
+  // therefore cost exactly what leaving them on cost, which is what a report of
+  // "no fps gain from disabling shadows" looks like from the outside.
+  //
+  // shadowStrength is a uniform, so this branch is uniform across the draw:
+  // every invocation takes the same side and the taps are genuinely skipped
+  // rather than merely masked. The dark term below is (1.0 - vis) * strength, so
+  // with strength at zero the result is identical either way — a pure
+  // deletion of work, not a change of look.
+  //
+  // The same reasoning the noise tint below already got, applied to the term
+  // that costs a hundred times more.
+  if (material.shadowStrength > 0.0 && shadowPossible) {
+  // The far cascade's taps, skipped entirely when nothing ever drew into it.
+  //
+  // This branch is the expensive one on a wide floor: it runs wherever the NEAR
+  // cascade does not reach, and the near cascade is a 64-unit box around the
+  // camera target, so a floor receding to the horizon takes it almost
+  // everywhere. Nine comparison taps, per pixel, on the largest draw in the
+  // frame — against a map that is cleared unless a stage is in the scene.
+  //
+  // Cleared depth compares as "no occluder", so the skipped path leaves vis at
+  // 1.0, which is exactly what the taps returned. Free, not cheaper.
+  if (material.farCascade > 0.0 && 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;
@@ -150,12 +190,27 @@ ${sceneFsOutWgsl()}@fragment fn fs(i: VO) -> FSOut {
     // 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
   // sixteen hash rounds a pixel for a tint of exactly 1.
   var noiseTint = 1.0;
   if (material.noiseStrength != 0.0) {
-    let noiseVal = fbmNoise(i.worldPos.xz * 3.0);
+    // One texture sample where four octaves of value noise used to be
+    // EVALUATED — sixteen hash rounds per pixel, on the largest draw in the
+    // frame. Bisection on the device that was slow pinned the ground's whole
+    // cost here: flat colour was smooth, the shader minus its shadow taps was
+    // still slow, and the shader minus only this was smooth. (0.33.2 built
+    // this same bake and measured no win — the cost then was the PCF. The
+    // instrument was right both times; the term changed.)
+    //
+    // The tile is the SAME fbm, baked once at init over a 64-p-unit period
+    // (~21 world units before it repeats — invisible at frost strengths), and
+    // the interior of the tile is bit-identical to the old evaluation because
+    // only lattice cells on the seam are wrapped. Sampled at level 0 with the
+    // repeat sampler: the old evaluation had no filtering either, so distant
+    // sparkle is unchanged rather than quietly "improved".
+    let noiseVal = textureSampleLevel(noiseTex, linearSampler, i.worldPos.xz * ${3 / 64}, 0.0).r;
     noiseTint = 1.0 + (noiseVal - 0.5) * material.noiseStrength;
   }
 
@@ -288,3 +343,52 @@ ${sceneIdWriteWgsl("out", `${GROUND_MATERIAL_ID}u`, `${GROUND_OBJECT_ID}u`)}  re
  */
 export const GROUND_MATERIAL_ID = 0xffff;
 export const GROUND_OBJECT_ID = 0xffff;
+/** Texel edge of the baked frost tile. 1024 over a 64-p-unit period is two
+ *  texels per finest-octave noise cell — the bake resolves everything the
+ *  evaluation produced. r8unorm: the value lives in [0,1] and feeds a 0.05
+ *  tint; eight bits is already 5x below what that tint can show. */
+export const GROUND_NOISE_SIZE = 1024;
+/**
+ * The frost fbm as a bake: identical math, periodic lattice.
+ *
+ * hash2/valueNoise/fbm are the ground's old helpers verbatim, with one change —
+ * each octave's lattice wraps at its own period (64 p-units at octave 0,
+ * doubling with frequency), so the tile is seamless under the repeat sampler.
+ * Wrapping only renames lattice cells on the seam; every interior cell hashes
+ * exactly as before, which is what makes the bake a relocation of the old
+ * pixels rather than a new look.
+ */
+export const GROUND_NOISE_BAKE_WGSL = /* wgsl */ `
+@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);
+}
+fn hash2(p: vec2f) -> f32 {
+  var p3 = fract(vec3f(p.x, p.y, p.x) * 0.1031);
+  p3 += dot(p3, vec3f(p3.y + 33.33, p3.z + 33.33, p3.x + 33.33));
+  return fract((p3.x + p3.y) * p3.z);
+}
+fn wrapCell(i: vec2f, period: f32) -> vec2f { return i - period * floor(i / period); }
+fn valueNoiseP(p: vec2f, period: f32) -> f32 {
+  let i = floor(p);
+  let f = fract(p);
+  let u = f * f * (3.0 - 2.0 * f);
+  return mix(mix(hash2(wrapCell(i, period)), hash2(wrapCell(i + vec2f(1.0, 0.0), period)), u.x),
+             mix(hash2(wrapCell(i + vec2f(0.0, 1.0), period)), hash2(wrapCell(i + vec2f(1.0, 1.0), period)), u.x), u.y);
+}
+@fragment fn fs(@builtin(position) pos: vec4f) -> @location(0) vec4f {
+  let p = pos.xy * (64.0 / ${GROUND_NOISE_SIZE}.0);
+  var v = 0.0;
+  var a = 0.5;
+  var pp = p;
+  var period = 64.0;
+  for (var o = 0; o < 4; o++) {
+    v += a * valueNoiseP(pp, period);
+    pp *= 2.0;
+    period *= 2.0;
+    a *= 0.5;
+  }
+  return vec4f(v, 0.0, 0.0, 1.0);
+}
+`;

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

@@ -1,2 +1,2 @@
-export declare const OUTLINE_SHADER_WGSL = "\nstruct CameraUniforms {\n  view: mat4x4f,\n  projection: mat4x4f,\n  viewPos: vec3f,\n  // Render-target height in device pixels (engine writes it each frame);\n  // width is recovered via the projection matrix's aspect.\n  viewportHeight: f32,\n};\n\nstruct MaterialUniforms {\n  edgeColor: vec4f,\n  edgeSize: f32,\n  _padding1: f32,\n  _padding2: f32,\n  _padding3: f32,\n};\n\n@group(0) @binding(0) var<uniform> camera: CameraUniforms;\n@group(0) @binding(1) var edgeSampler: sampler;\n@group(1) @binding(0) var<storage, read> skinMats: array<mat4x4f>;\n@group(2) @binding(0) var<uniform> material: MaterialUniforms;\n@group(2) @binding(1) var diffuseTexture: texture_2d<f32>;\n\nstruct VertexOutput {\n  @builtin(position) position: vec4f,\n  @location(0) uv: vec2f,\n};\n\n@vertex fn vs(\n  @location(0) position: vec3f,\n  @location(1) normal: vec3f,\n  @location(2) uv: vec2f,\n  @location(3) joints0: vec4<u32>,\n  @location(4) weights0: vec4<f32>\n) -> VertexOutput {\n  var output: VertexOutput;\n  let pos4 = vec4f(position, 1.0);\n\n  let weightSum = weights0.x + weights0.y + weights0.z + weights0.w;\n  let invWeightSum = select(1.0, 1.0 / weightSum, weightSum > 0.0001);\n  let normalizedWeights = select(vec4f(1.0, 0.0, 0.0, 0.0), weights0 * invWeightSum, weightSum > 0.0001);\n\n  var skinnedPos = vec4f(0.0, 0.0, 0.0, 0.0);\n  var skinnedNrm = vec3f(0.0, 0.0, 0.0);\n  for (var i = 0u; i < 4u; i++) {\n    let j = joints0[i];\n    let w = normalizedWeights[i];\n    let m = skinMats[j];\n    skinnedPos += (m * pos4) * w;\n    let r3 = mat3x3f(m[0].xyz, m[1].xyz, m[2].xyz);\n    skinnedNrm += (r3 * normal) * w;\n  }\n  let worldPos = skinnedPos.xyz;\n  let worldNormal = normalize(skinnedNrm);\n\n  let clipPos = camera.projection * camera.view * vec4f(worldPos, 1.0);\n\n  // babylon-mmd: screenNormal = normalize((view * worldNormal).xy)\n  let viewNormal = (camera.view * vec4f(worldNormal, 0.0)).xyz;\n  let snLen = length(viewNormal.xy);\n  let screenNormal = select(vec2f(0.0, 0.0), viewNormal.xy / snLen, snLen > 1e-5);\n\n  // Reference-height normalization (babylon-mmd ships this variant commented\n  // out as `renderHeight = 1080`): thickness is a constant FRACTION of the\n  // frame \u2014 2\u00B7edgeSize px at 1080p \u2014 so retina DPR and 4K export don't thin\n  // the rims to sub-pixel. Width follows the projection aspect.\n  // projection[1][1]/projection[0][0] = width/height for a symmetric frustum.\n  let aspect = camera.projection[1][1] / camera.projection[0][0];\n  let viewport = vec2f(1080.0 * aspect, 1080.0);\n\n  // NDC offset = edgeSize \u00B7 4/viewport, \u00D7w so the perspective divide cancels:\n  // constant screen thickness at any distance (babylon-mmd parity).\n  let offset = screenNormal * (material.edgeSize * 4.0 / viewport) * clipPos.w;\n  output.position = vec4f(clipPos.xy + offset, clipPos.z, clipPos.w);\n  output.uv = uv;\n  return output;\n}\n\nstruct FSOut { @location(0) color: vec4f, @location(1) mask: vec4f };\n@fragment fn fs(input: VertexOutput) -> FSOut {\n  // Rim alpha FOLLOWS the fabric's texture alpha instead of a hard alpha test:\n  // MMD draws blend-material edges solid (only cutout materials alpha-test), so\n  // a 0.4 discard erased the whole hull on semi-transparent cloth \u2014 stockinged\n  // legs crossing lost their outline entirely. Modulating instead keeps a\n  // proportional rim on sheer weave (never a solid black hull) and still\n  // discards true cut-out margins like hair-card borders.\n  let texA = textureSample(diffuseTexture, edgeSampler, input.uv).a;\n  if (texA < 0.05) {\n    discard;\n  }\n  var out: FSOut;\n  out.color = vec4f(material.edgeColor.rgb, material.edgeColor.a * texA);\n  out.mask = vec4f(1.0, 1.0, 0.0, out.color.a);\n  return out;\n}\n";
+export declare function outlineShaderWgsl(): string;
 //# sourceMappingURL=outline.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"outline.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/outline.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,mBAAmB,ksHAgG/B,CAAA"}
+{"version":3,"file":"outline.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/outline.ts"],"names":[],"mappings":"AAoBA,wBAAgB,iBAAiB,IAAI,MAAM,CAqG1C"}

package/dist/shaders/passes/outline.js

@@ -11,7 +11,12 @@
 //      MODULATES the rim's alpha by it (discarding only near-zero cut-out
 //      margins) — sheer fabric gets a proportional rim, never a solid black
 //      hull, without dropping the author's edge flag.
-export const OUTLINE_SHADER_WGSL = /* wgsl */ `
+// A FUNCTION rather than a constant, for the reason commonFsOutWgsl is one: the
+// fragment outputs depend on whether the device carries the id attachment, and
+// a string baked at import cannot know what the device said.
+import { sceneFsOutWgsl, sceneIdPadWgsl } from "./scene-contract";
+export function outlineShaderWgsl() {
+    return /* wgsl */ `
 struct CameraUniforms {
   view: mat4x4f,
   projection: mat4x4f,
@@ -90,7 +95,10 @@ struct VertexOutput {
   return output;
 }
 
-struct FSOut { @location(0) color: vec4f, @location(1) mask: vec4f };
+// The id output is declared and padded, never written for real: a hull would
+// overwrite the id of the body it traces, so the pipeline takes the id target at
+// writeMask 0. Declared all the same — see sceneFsOutWgsl.
+${sceneFsOutWgsl({ name: "FSOut", aux: "mask" })}
 @fragment fn fs(input: VertexOutput) -> FSOut {
   // Rim alpha FOLLOWS the fabric's texture alpha instead of a hard alpha test:
   // MMD draws blend-material edges solid (only cutout materials alpha-test), so
@@ -105,6 +113,7 @@ struct FSOut { @location(0) color: vec4f, @location(1) mask: vec4f };
   var out: FSOut;
   out.color = vec4f(material.edgeColor.rgb, material.edgeColor.a * texA);
   out.mask = vec4f(1.0, 1.0, 0.0, out.color.a);
-  return out;
+${sceneIdPadWgsl("out")}  return out;
 }
 `;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"particles.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/particles.ts"],"names":[],"mappings":"AAwBA,sEAAsE;AACtE,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,iFAAiF;IACjF,KAAK,EAAE,MAAM,CAAA;IACb;;mFAE+E;IAC/E,UAAU,EAAE,MAAM,CAAA;IAClB,+EAA+E;IAC/E,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB,CAAA;AAiCD,qDAAqD;AACrD,KAAK,aAAa,GAAG,OAAO,GAAG,UAAU,CAAA;AAEzC,KAAK,cAAc,GAAG;IACpB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,qFAAqF;IACrF,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,aAAa,CAAA;IACpB,qEAAqE;IACrE,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAED,oEAAoE;AACpE,eAAO,MAAM,eAAe,KAAK,CAAA;AAkDjC,oDAAoD;AACpD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAOpE;AAED,gFAAgF;AAChF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AAED,wDAAwD;AACxD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAE9D;AAED,qFAAqF;AACrF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAMlG;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CA0CxF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CA6GvF"}
+{"version":3,"file":"particles.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/particles.ts"],"names":[],"mappings":"AAyBA,sEAAsE;AACtE,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,iFAAiF;IACjF,KAAK,EAAE,MAAM,CAAA;IACb;;mFAE+E;IAC/E,UAAU,EAAE,MAAM,CAAA;IAClB,+EAA+E;IAC/E,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB,CAAA;AAiCD,qDAAqD;AACrD,KAAK,aAAa,GAAG,OAAO,GAAG,UAAU,CAAA;AAEzC,KAAK,cAAc,GAAG;IACpB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,qFAAqF;IACrF,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,aAAa,CAAA;IACpB,qEAAqE;IACrE,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAED,oEAAoE;AACpE,eAAO,MAAM,eAAe,KAAK,CAAA;AAkDjC,oDAAoD;AACpD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAOpE;AAED,gFAAgF;AAChF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AAED,wDAAwD;AACxD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAE9D;AAED,qFAAqF;AACrF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAMlG;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CA0CxF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CAgHvF"}

package/dist/shaders/passes/particles.js

@@ -5,6 +5,7 @@ import { anchorAliasWgsl } from "../anchor-table";
 import { midiApi } from "../midi-api";
 import { CAST_API } from "../cast-api";
 import { clockApi, EFFECT_MATH_API, PARTICLE_STRUCT_WGSL, trailSlotsApi, viewportApi } from "./hosted-api";
+import { sceneIdFieldWgsl, sceneIdPadWgsl } from "./scene-contract";
 /**
  * The trail accessors, in the PARTICLE module.
  *
@@ -247,7 +248,10 @@ struct FSOut {
   // rejected outright — "reading alpha but it is missing from fragment output".
   // The material shaders declare vec4f here for the same reason.
   @location(1) mask: vec4f,
-}
+  // Declared whenever the pass carries the attachment, and padded rather than
+  // written: a particle is not a thing you would address by id, so its pipeline
+  // takes this target at writeMask 0. Declared anyway — see sceneFsOutWgsl.
+${sceneIdFieldWgsl()}}
 
 @fragment
 fn fs(in: VSOut) -> FSOut {
@@ -273,7 +277,7 @@ fn fs(in: VSOut) -> FSOut {
   // not geometry, was the banding that survived every geometry fix.
   let mg = select(vec2f(select(0.0, 1.0, BLOOM), 1.0), vec2f(select(0.0, c.a, BLOOM), c.a), ADDITIVE);
   out.mask = vec4f(mg.x, mg.y, 0.0, c.a);
-  return out;
+${sceneIdPadWgsl("out")}  return out;
 }
 `);
 }

package/dist/shaders/passes/scene-contract.d.ts

@@ -105,12 +105,19 @@ export declare function sceneColorFormats(formats: SceneFormats): GPUTextureForm
  * author. The struct and the targets above have to agree on count and order,
  * and they now disagree in one file rather than in five.
  *
- * Only the shaders that will GAIN an output take this today — the materials
- * (hand-written and graph-generated alike, through COMMON_FS_OUT_WGSL) and the
- * ground. Outline, particles and ribbons keep their own declarations on
- * purpose: they never write the id, so they would take an `id: false` argument
- * forever, and their structs carry comments about their own blend that belong
- * where they are.
+ * EVERY scene-pass shader takes this — outline, particles, ribbons and the
+ * depth prepass included, none of which write a meaningful id (and the prepass
+ * no meaningful colour either). They did not, once. The reasoning was that a
+ * target at writeMask 0 needs no matching output: true of Dawn, and the reading
+ * of gpuweb#1918 this file used to assert. It is not a reading every browser
+ * shares, and the failure mode when a browser disagrees is the worst kind —
+ * createRenderPipeline does not throw, it returns a pipeline that is already
+ * invalid, and the pass that binds it is dropped whole. Missing geometry, clean
+ * console, and a bug that reproduces on one vendor's browser only.
+ *
+ * So the rule is now the strict one, and it costs nothing to hold: declare
+ * every output the pass has attachments for, and let writeMask decide what is
+ * kept. A shader with no id to write pads it — see sceneIdPadWgsl.
  */
 export declare function sceneFsOutWgsl(opts?: {
     name?: string;
@@ -124,5 +131,30 @@ export declare function sceneFsOutWgsl(opts?: {
  * ask the device what it supports.
  */
 export declare function sceneIdWriteWgsl(out: string, material: string, object: string): string;
+/**
+ * Just the id FIELD, for a shader that keeps its own struct.
+ *
+ * Particles and ribbons declare their outputs by hand because the comments on
+ * their aux field are about their own blend and belong beside it — taking the
+ * whole struct from sceneFsOutWgsl would move that prose away from what it
+ * explains. They still need the id output when the pass has the attachment, so
+ * they splice this in and pad it with sceneIdPadWgsl.
+ */
+export declare function sceneIdFieldWgsl(): string;
+/**
+ * The id assignment for a shader that has no id to give.
+ *
+ * The counterpart to the strict rule on sceneFsOutWgsl: outline hulls,
+ * particles, ribbons and the depth prepass all declare the output because the
+ * pass has the attachment, and all of them take writeMask 0, so what they
+ * assign is never stored. Zero, which is the reserved "nothing" id the pass
+ * clears to — so if one of these ever did reach the target, it would read as
+ * absence rather than as a plausible wrong answer pointing at material 0.
+ *
+ * A separate function from sceneIdWriteWgsl rather than a call to it with "0u"
+ * twice, because the two say different things: that one records an identity,
+ * this one satisfies a declaration.
+ */
+export declare function sceneIdPadWgsl(out: string): string;
 export {};
 //# sourceMappingURL=scene-contract.d.ts.map

package/dist/shaders/passes/scene-contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene-contract.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/scene-contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;uDAEuD;AACvD,MAAM,MAAM,YAAY,GAAG;IACzB,+CAA+C;IAC/C,GAAG,EAAE,gBAAgB,CAAA;IACrB,iEAAiE;IACjE,GAAG,EAAE,gBAAgB,CAAA;CACtB,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,EAAE,gBAA6B,CAAA;AAkB3D,8DAA8D;AAC9D,wBAAgB,SAAS,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAE3C;AAED,wBAAgB,aAAa,IAAI,OAAO,CAEvC;AAED;;;;;;GAMG;AACH,KAAK,gBAAgB;AACnB,2DAA2D;AACzD,UAAU;AACZ;;+CAE+C;GAC7C,QAAQ;AACV,uEAAuE;GACrE,SAAS;AACX,iEAAiE;GAC/D,UAAU;AACZ;;;mDAGmD;GACjD,mBAAmB;AACrB;;;oCAGoC;GAClC,OAAO;AACT;;;kDAGkD;GAChD,eAAe,CAAA;AAwEnB;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,gBAAgB,EAAE,OAAO,EAAE,YAAY,GAAG,mBAAmB,EAAE,CAqBhG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,YAAY,GAAG,gBAAgB,EAAE,CAE3E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,IAAI,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAmB7E;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEtF"}
+{"version":3,"file":"scene-contract.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/scene-contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;uDAEuD;AACvD,MAAM,MAAM,YAAY,GAAG;IACzB,+CAA+C;IAC/C,GAAG,EAAE,gBAAgB,CAAA;IACrB,iEAAiE;IACjE,GAAG,EAAE,gBAAgB,CAAA;CACtB,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,EAAE,gBAA6B,CAAA;AAkB3D,8DAA8D;AAC9D,wBAAgB,SAAS,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAE3C;AAED,wBAAgB,aAAa,IAAI,OAAO,CAEvC;AAED;;;;;;GAMG;AACH,KAAK,gBAAgB;AACnB,2DAA2D;AACzD,UAAU;AACZ;;+CAE+C;GAC7C,QAAQ;AACV,uEAAuE;GACrE,SAAS;AACX,iEAAiE;GAC/D,UAAU;AACZ;;;mDAGmD;GACjD,mBAAmB;AACrB;;;oCAGoC;GAClC,OAAO;AACT;;;kDAGkD;GAChD,eAAe,CAAA;AA0EnB;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,gBAAgB,EAAE,OAAO,EAAE,YAAY,GAAG,mBAAmB,EAAE,CAoBhG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,YAAY,GAAG,gBAAgB,EAAE,CAE3E;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,cAAc,CAAC,IAAI,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAmB7E;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEtF;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAElD"}