reze-engine 0.50.2 → 0.50.4

package/dist/shaders/passes/depth-prepass.js

@@ -1,16 +1,34 @@
-// 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.
-export const TRANSPARENT_DEPTH_PREPASS_WGSL = /* wgsl */ `
+//
+// 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.
+import { sceneFsOutWgsl, sceneIdPadWgsl } from "./scene-contract";
+export function transparentDepthPrepassWgsl() {
+    return /* wgsl */ `
 struct CameraUniforms { view: mat4x4f, projection: mat4x4f, viewPos: vec3f, _p: f32, };
 struct MaterialUniforms {
   diffuseColor: vec3f,
@@ -24,7 +42,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,
 };
 
@@ -49,8 +69,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/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,CAqRzC;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;
   }
 
@@ -184,8 +239,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);
@@ -248,28 +303,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);
@@ -298,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"}

package/dist/shaders/passes/scene-contract.js

@@ -89,12 +89,14 @@ const ADD_PREMULTIPLIED = {
     alpha: { srcFactor: "zero", dstFactor: "one", operation: "add" },
 };
 /**
- * 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
@@ -127,11 +129,10 @@ const BLENDS = {
  */
 export function sceneTargets(cls, formats) {
     const targets = 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 },
@@ -168,12 +169,19 @@ export function sceneColorFormats(formats) {
  * 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) {
     const name = opts?.name ?? "FSOut";
@@ -205,3 +213,32 @@ ${id}};
 export function sceneIdWriteWgsl(out, material, object) {
     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() {
+    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) {
+    return mrtIds ? `  ${out}.id = vec2u(0u, 0u);\n` : "";
+}

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

@@ -1 +1 @@
-{"version":3,"file":"trails.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/trails.ts"],"names":[],"mappings":"AAwBA,KAAK,WAAW,GAAG;IACjB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,yDAAyD;IACzD,KAAK,EAAE,MAAM,CAAA;IACb;oEACgE;IAChE,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,8DAA8D;IAC9D,KAAK,EAAE,OAAO,GAAG,UAAU,CAAA;IAC3B,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAA;AAEnC,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAKjF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE;IACJ,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,EAAE,CAAA;IACf;;;;kFAI8E;IAC9E,SAAS,EAAE,OAAO,CAAA;CACnB,GACA,MAAM,CA6SR"}
+{"version":3,"file":"trails.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/trails.ts"],"names":[],"mappings":"AAyBA,KAAK,WAAW,GAAG;IACjB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,yDAAyD;IACzD,KAAK,EAAE,MAAM,CAAA;IACb;oEACgE;IAChE,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,8DAA8D;IAC9D,KAAK,EAAE,OAAO,GAAG,UAAU,CAAA;IAC3B,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAA;AAEnC,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAKjF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE;IACJ,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,EAAE,CAAA;IACf;;;;kFAI8E;IAC9E,SAAS,EAAE,OAAO,CAAA;CACnB,GACA,MAAM,CAwUR"}