reze-engine 0.50.2 → 0.50.4

package/src/shaders/cast-layout.ts

@@ -14,7 +14,50 @@
  * the whole engine failing to start on an import order nobody chose.
  */
 export const EFFECT_SUBJECTS = 4
-export const EFFECT_ANCHORS = 8
+/**
+ * Bone anchors, for the WHOLE SCENE rather than per effect — this is an address
+ * space that every installed effect draws slots from, and an effect asking for
+ * one the table has already given away is told so and has it dropped.
+ *
+ * 8 was reachable, and quietly: two effects each wanting two hands, two feet and
+ * a head is ten, so the second one silently lost its ribbons to a diagnostic
+ * nobody was reading. 16 is double the headroom for 131KB of storage buffer,
+ * where 8 cost 66KB.
+ *
+ * The cost really is only that. The per-frame upload is bounded by the last
+ * TRAILED slot, not by this cap (see the writeBuffer in updateCastBuffer), so a
+ * scene using three anchors uploads three anchors' worth whatever this says.
+ * The CPU-side path rings are keyed by (model, slot) and allocated on use. And
+ * effects never index this directly — they loop to rzTrailCount / rzSubjectCount
+ * and read through rzAnchor/rzTrail, both of which bounds-check against it.
+ *
+ * It stays a compile-time constant because the accessors in cast-api.ts are
+ * interpolated into every effect module as WGSL literals; making it dynamic
+ * means resizing the buffer and recompiling every installed effect whenever the
+ * scene's anchor count grows, which is a different feature from raising a number
+ * that was never load-bearing.
+ */
+export const EFFECT_ANCHORS = 16
+/**
+ * Path samples kept per trailed anchor — 128 at the 60Hz sampling rate is a
+ * ~2.1 second ribbon.
+ *
+ * Briefly 256, and reverted with the reason, because the reason is the useful
+ * part: a ribbon's cost is not its geometry, it is its FRAGMENTS. It is a wide
+ * translucent strip blended additively into the HDR target at the pass's sample
+ * count, and it overlaps itself — so its cost tracks the screen AREA it covers,
+ * and a twice-as-long ribbon covers roughly twice as much.
+ *
+ * That lands very differently on the two backends. Overdraw and blend bandwidth
+ * are what a tile-based GPU pays for most and what an immediate-mode desktop GPU
+ * absorbs, which is why ribbons were reported as costing far more on Safari than
+ * on Chrome for the same scene. Doubling this doubles the one thing already
+ * known to be the bottleneck there.
+ *
+ * Raising it is still SAFE — effects loop to rzTrailCount and nothing breaks —
+ * it is simply not cheap, and the cost shows up on the slower of the two
+ * browsers rather than the one it would be measured on.
+ */
 export const EFFECT_TRAIL_SAMPLES = 128
 /** vec4 slot where the trails begin — after the subjects and the anchors. */
 export const EFFECT_TRAIL_BASE = EFFECT_SUBJECTS * 3 + EFFECT_ANCHORS * EFFECT_SUBJECTS * 3

package/src/shaders/materials/common.ts

@@ -73,7 +73,13 @@ struct MaterialUniforms {
 };
 
 struct VertexOutput {
-  @builtin(position) position: vec4f,
+  // @invariant: the opaque depth prepass rasterises this same skinned position
+  // through a DIFFERENT shader module, and the colour pass then depth-tests
+  // less-equal against what it wrote. Without invariance a backend is free to
+  // optimise the two position computations differently, and a one-ulp
+  // disagreement is a pixel of missing character. Invariance pins both to the
+  // same result; it costs only that freedom.
+  @builtin(position) @invariant position: vec4f,
   @location(0) normal: vec3f,
   @location(1) uv: vec2f,
   @location(2) worldPos: vec3f,

package/src/shaders/materials/nodes.ts

@@ -216,18 +216,26 @@ fn curve5(t0: f32, y0: f32, y1: f32, y2: f32, y3: f32, y4: f32) -> f32 {
   let t = clamp(t0, 0.0, 1.0) * 4.0;
   let i = min(floor(t), 3.0);
   let f = t - i;
-  // A var, not a let: WGSL only allows a dynamic index on a REFERENCE, and a
-  // let-bound array is a value. Indexing it with a runtime k is a compile error —
-  // and because this file is concatenated into every material shader, that error
-  // took every graph in the library down with it, not just curves.
-  var ys = array<f32, 5>(y0, y1, y2, y3, y4);
+  // NO local array, deliberately. This used to build array<f32, 5> and index it
+  // with the runtime k — and a dynamic index on function-local memory is the one
+  // construct this codebase has already caught Metal lowering to a
+  // per-invocation copy plus a switch (the filmic LUT note in composite.ts).
+  // rgb_curve calls this three times per node per pixel, so on a graph-heavy
+  // close-up that lowering was paid in the hottest loop the frame has. Four
+  // segments select cleanly: the values below are the SAME subtractions the
+  // array indexing produced, chosen by k instead of loaded through it —
+  // bit-identical results, no local memory, nothing for the backend to spill.
   let k = i32(i);
-  let pa = ys[k];
-  let pb = ys[k + 1];
+  let s0 = y1 - y0;
+  let s1 = y2 - y1;
+  let s2 = y3 - y2;
+  let s3 = y4 - y3;
+  let pa = select(select(y0, y1, k == 1), select(y2, y3, k == 3), k >= 2);
+  let pb = select(select(y1, y2, k == 1), select(y3, y4, k == 3), k >= 2);
   // Secants either side of each knot, clamped at the ends.
-  let dPrev = select(ys[max(k, 1)] - ys[max(k, 1) - 1], pb - pa, k == 0);
   let dHere = pb - pa;
-  let dNext = select(ys[min(k + 2, 4)] - ys[min(k + 1, 3)], pb - pa, k == 3);
+  let dPrev = select(s0, select(s1, s2, k == 3), k >= 2);
+  let dNext = select(select(s1, s2, k == 1), s3, k >= 2);
   let m0 = curve_slope(dPrev, dHere);
   let m1 = curve_slope(dHere, dNext);
   let f2 = f * f;

package/src/shaders/passes/depth-prepass.ts

@@ -1,17 +1,36 @@
-// Depth-only prepass for the TRANSPARENT bucket. Transparent color draws keep
-// depth write OFF so self-overlapping sheer cloth blends both layers instead of
-// a triangle-order patchwork — but that leaves no depth record, so anything
-// drawn later (the outline hulls) shows straight through the fabric as black
-// shapes. This pass re-draws the transparent geometry depth-only AFTER its
-// color pass: solid-enough texels (alpha ≥ 0.5) write depth, so outlines get
-// occluded behind fabric exactly like they are behind opaque cloth, while
-// truly sheer texels (a veil) stay non-occluding.
+// The depth-only prime, one module behind four pipelines.
+//
+// The oldest fps complaint the engine had — zoom close and the frame drops, in
+// every material generation — was per-fragment shading TIMES layering: an MMD
+// model at close-up is cloth over body over face under hair, author-order drawn,
+// every buried layer fully shaded and then covered. This module lets depth go
+// down FIRST so the colour passes shade each pixel once:
+//
+//   · opaque prepass  (CUTOFF 0.5) — plain auto-class opaque draws, before the
+//     opaque colour walk. See drawOpaqueDepthPrepass for who is in and why.
+//   · hair prime      (CUTOFF 1.0, stencil not-equal) — between the non-hair and
+//     hair colour walks, fenced off the eye silhouette the see-through-hair
+//     stencil pass needs. See drawHairDepthPrime.
+//   · transparent solid prime (CUTOFF 1.0) — a translucent material's alpha-1
+//     texels, where over-blending is plain replacement and the buried work
+//     provably never shows. See drawTransparentSolidPrepass.
+//   · transparent depth prepass (CUTOFF 0.5, AFTER colour) — the original
+//     occupant, dormant: re-records sheer fabric's depth so outline hulls are
+//     occluded behind it. Kept for a future OIT path.
 //
 // Reuses mainPipelineLayout: camera g0b0, diffuseSampler g0b2, skinMats g1b0,
 // diffuse texture g2b0, material uniforms g2b1 — the same bind groups the
 // color draws already set, so drawing it costs no extra binding work.
+//
+// A FUNCTION rather than the constant it was, for the reason commonFsOutWgsl is
+// one: the fragment outputs below depend on whether the device carries the id
+// attachment, and that answer does not exist at import time. The constant could
+// not have taken the outputs at all, which is most of why it did not have them.
 
-export const TRANSPARENT_DEPTH_PREPASS_WGSL = /* wgsl */ `
+import { sceneFsOutWgsl, sceneIdPadWgsl } from "./scene-contract"
+
+export function transparentDepthPrepassWgsl(): string {
+  return /* wgsl */ `
 struct CameraUniforms { view: mat4x4f, projection: mat4x4f, viewPos: vec3f, _p: f32, };
 struct MaterialUniforms {
   diffuseColor: vec3f,
@@ -25,7 +44,9 @@ struct MaterialUniforms {
 @group(2) @binding(1) var<uniform> material: MaterialUniforms;
 
 struct VSOut {
-  @builtin(position) position: vec4f,
+  // @invariant, to the same end as the material VertexOutput: the colour pass
+  // must land on exactly the depths this wrote.
+  @builtin(position) @invariant position: vec4f,
   @location(0) uv: vec2f,
 };
 
@@ -50,8 +71,28 @@ struct VSOut {
   return o;
 }
 
-@fragment fn fs(in: VSOut) {
+// Every attachment the pass carries, declared and then not written: the
+// pipeline takes all of them at writeMask 0 (see sceneTargets), so what this
+// returns is discarded by the hardware and only the depth write survives — which
+// is the entire purpose of the pass. Declaring them anyway is what keeps the
+// pipeline valid on a browser that requires an output per target rather than
+// per WRITTEN target. Costs one dead struct store on a fragment that already
+// runs, because the alpha test below needs it to.
+${sceneFsOutWgsl({ name: "PrepassOut", aux: "mask" })}
+// The cutout threshold, per pipeline. 0.5 is the OPAQUE prime's "solid enough"
+// — safe there because opaque colour replaces rather than blends. The
+// TRANSPARENT prime overrides it to 1.0: a translucent fragment's blend reads
+// what is behind it, so only a texel at EXACTLY alpha 1 — where over-blending
+// collapses to plain replacement and the destination stops mattering — may
+// claim depth ahead of its buried layers without changing the pixel.
+override CUTOFF: f32 = 0.5;
+@fragment fn fs(in: VSOut) -> PrepassOut {
   let a = material.alpha * textureSample(diffuseTexture, diffuseSampler, in.uv).a;
-  if (a < 0.5) { discard; }
+  if (a < CUTOFF) { discard; }
+  var out: PrepassOut;
+  out.color = vec4f(0.0);
+  out.mask = vec4f(0.0);
+${sceneIdPadWgsl("out")}  return out;
 }
 `
+}

package/src/shaders/passes/ground.ts

@@ -20,7 +20,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.
@@ -42,33 +48,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;
@@ -121,8 +106,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;
@@ -152,12 +192,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;
   }
 
@@ -186,8 +241,8 @@ ${sceneFsOutWgsl()}@fragment fn fs(i: VO) -> FSOut {
   // 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, and no dependence on the floor's
-  // opacity either: mirror is on or off, and when it is on it SHOWS — the same
+  // 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);
@@ -250,28 +305,18 @@ ${sceneFsOutWgsl()}@fragment fn fs(i: VO) -> FSOut {
   // 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: received shadow, ground
-  // surface, reflection, grid. Each with its own coverage, none scaling
-  // another.
-  //
-  // THE MIRROR SITS ABOVE THE SURFACE, and that ordering is the whole rule.
-  // Underneath it, the floor's own opacity covered the reflection — and did it
-  // inconsistently, because BOTH layers carry the radial edgeFade: at opacity
-  // 1 the surface stopped covering wherever the plane fades out, so the
-  // reflection returned along the rim and read as a bug that came and went
-  // with the camera angle. What a mirror shows cannot depend on how solid the
-  // thing it is made of happens to be.
-  //
-  // The catcher's order against it no longer matters — catchA already carries
-  // (1 - mirror), so the two are never both present.
-  var pm = vec3f(0.0);
-  var cov = catchA;
-  // Surface over the received shadow.
+  // 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);
-  // The reflection over the surface, at full strength whatever the opacity.
-  pm = reflShadowed * mirrA + pm * (1.0 - mirrA);
-  cov = mirrA + cov * (1.0 - mirrA);
   // 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);
@@ -301,3 +346,54 @@ ${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/src/shaders/passes/outline.ts

@@ -12,7 +12,14 @@
 //      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(): string {
+  return /* wgsl */ `
 struct CameraUniforms {
   view: mat4x4f,
   projection: mat4x4f,
@@ -91,7 +98,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
@@ -106,6 +116,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/src/shaders/passes/particles.ts

@@ -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"
 // GPU particles for user effects: a compute step and an instanced quad draw.
 //
 // Its own shader MODULE rather than more source spliced into composite.ts, for
@@ -307,7 +308,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 {
@@ -333,7 +337,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/src/shaders/passes/scene-contract.ts

@@ -143,12 +143,14 @@ const ADD_PREMULTIPLIED: GPUBlendState = {
 }
 
 /**
- * Which classes actually WRITE an id, and so gain a fragment output for it.
+ * Which classes write a MEANINGFUL id.
  *
- * Everything else keeps its shader exactly as it is and takes the id target at
- * writeMask 0 — legal, specified, and free. The alternative (leaving the target
- * off those pipelines) is not available: every pipeline in a pass must agree
- * with the pass's attachments.
+ * Not the same question as which shaders declare the output — every scene-pass
+ * shader declares all three now (see sceneFsOutWgsl). This set decides only
+ * whose id survives: writeMask 0xf here, writeMask 0 for everyone else, so the
+ * others compute an id nothing stores. Leaving the target off those pipelines
+ * is not available: every pipeline in a pass must agree with the pass's
+ * attachments.
  *
  * The ground is in because a mark placed by id needs the floor to have one.
  * Transparent fabric writes ids too — dissolving a dress needs the dress's own
@@ -184,11 +186,10 @@ const BLENDS: Record<Exclude<SceneRenderClass, "depth-prepass">, [GPUBlendState,
 export function sceneTargets(cls: SceneRenderClass, formats: SceneFormats): GPUColorTargetState[] {
   const targets: GPUColorTargetState[] =
     cls === "depth-prepass"
-      ? // Format only, and writeMask 0. Note the asymmetry this leans on, which
-        // is the same one the id target leans on below: a target the shader has
-        // no output for is legal at writeMask 0 (gpuweb#1918), while an output
-        // with no target is NOT governed (gpuweb#5341). This is the specified
-        // direction, and it is the only one this file ever uses.
+      ? // Format only, and writeMask 0 — the pipeline writes no colour. It still
+        // DECLARES every output, which is the part that used to be missing; see
+        // the note on sceneFsOutWgsl about why writeMask 0 is not a licence to
+        // leave the output off.
         [
           { format: formats.hdr, writeMask: 0 },
           { format: formats.aux, writeMask: 0 },
@@ -226,12 +227,19 @@ export function sceneColorFormats(formats: SceneFormats): GPUTextureFormat[] {
  * 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 function sceneFsOutWgsl(opts?: { name?: string; aux?: string }): string {
   const name = opts?.name ?? "FSOut"
@@ -264,3 +272,34 @@ ${id}};
 export function sceneIdWriteWgsl(out: string, material: string, object: string): string {
   return mrtIds ? `  ${out}.id = vec2u(${material}, ${object});\n` : ""
 }
+
+/**
+ * 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 function sceneIdFieldWgsl(): string {
+  return mrtIds ? `  @location(2) id: vec2u,\n` : ""
+}
+
+/**
+ * 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 function sceneIdPadWgsl(out: string): string {
+  return mrtIds ? `  ${out}.id = vec2u(0u, 0u);\n` : ""
+}