@driftengine/core 4.4.2 → 4.5.0

package/dist/render/shaders/gpudriven/blendRaster.wgsl.js

@@ -80,6 +80,27 @@ fn oitResolved(accum: vec4<f32>, reveal: f32) -> vec4<f32> {
   return vec4<f32>(average * covered, covered);
 }
 `;
+/**
+ * Glass over its own shading, as the forward path draws it: `gpudriven/lit.ts`'s `glassShade`,
+ * which `scripts/gpu-parity.mjs` holds this to. Schlick at 0.04 with the angle unsigned — a pane
+ * passes the same light seen from either side — and floored at the forward path's grazing 0.05.
+ */
+const GLASS_SHADE_WGSL = /* wgsl */ `
+fn glassShade(
+  own: vec3<f32>,
+  seen: vec3<f32>,
+  transmission: f32,
+  frost: f32,
+  tint: vec3<f32>,
+  cosView: f32,
+  sunGlow: vec3<f32>,
+) -> vec3<f32> {
+  let c = clamp(abs(cosView), 0.05, 1.0);
+  let fresnel = 0.04 + 0.96 * pow(1.0 - c, 5.0);
+  let shown = transmission * (1.0 - fresnel);
+  return own + (seen * tint - own) * shown + sunGlow * tint * (frost * transmission);
+}
+`;
 export const BLEND_RASTER_WGSL = /* wgsl */ `
 struct BlendVarying {
   @builtin(position) position: vec4<f32>,
@@ -106,6 +127,12 @@ ${FRAME_BLOCK_WGSL}
 @group(0) @binding(9) var environmentMap: texture_2d_array<f32>;
 @group(0) @binding(10) var environmentSampler: sampler;
 ${decodeResourcesWgsl({ group: 0, latents: 11, clampSampler: 12, repeatSampler: 13, nodes: 14, weights: 15 })}
+/**
+ * What the opaque half drew, with a mip chain on a frame whose scene holds glass: a pane shows it,
+ * a frosted one a coarser level of it. Read only by a material whose transmission is not zero.
+ */
+@group(0) @binding(16) var opaqueColour: texture_2d<f32>;
+@group(0) @binding(17) var opaqueSampler: sampler;
 fn decodeLatentSize() -> f32 {
   return frame.size.w;
 }
@@ -124,6 +151,7 @@ ${MESH_TRANSFORM_WGSL}
 ${SHADE_LIGHTING_WGSL}
 ${FOG_WGSL}
 ${OIT_WGSL}
+${GLASS_SHADE_WGSL}
 
 const NO_PROGRAM_HERE: u32 = ${0xffffffff}u;
 
@@ -239,7 +267,25 @@ fn blendFrag(in: BlendVarying) -> BlendTargets {
    * distance — which is the whole reason this pipeline gained a fog.
    */
   let toward = distance(in.world, frame.eye.xyz);
-  let colour = mix(litColour(surface, room), mediumColour(), mediumFog(toward, in.world.y));
+  let fog = mediumFog(toward, in.world.y);
+  var colour = mix(litColour(surface, room), mediumColour(), fog);
+  /*
+   * **Glass shows what is behind it**, as the forward path's glass branch does: the opaque half's
+   * picture at this pixel, at the level frost picks, two short of the chain's end so a fully frosted
+   * pane keeps the large light and dark behind it. The sun glows through from the pane's far side,
+   * after the haze as the forward path adds it. A pane is seen from both sides, so its facing is
+   * the side toward the eye.
+   */
+  let transmission = entry.extra.y;
+  if (transmission > 0.0) {
+    let size = vec2<f32>(textureDimensions(opaqueColour, 0));
+    let levels = max(floor(log2(max(size.x, size.y))) - 2.0, 0.0);
+    let seen = textureSampleLevel(opaqueColour, opaqueSampler, in.position.xy / size, entry.extra.z * levels).xyz;
+    let cosView = dot(surface.normal, toEye);
+    let facing = select(surface.normal, -surface.normal, cosView < 0.0);
+    let sunGlow = frame.lightColour.xyz * max(-dot(facing, frame.lightDir.xyz), 0.0) * (1.0 - fog);
+    colour = glassShade(colour, seen, transmission, entry.extra.z, entry.glassTint.xyz, cosView, sunGlow);
+  }
 
   /*
    * **The distance to the eye, not the clip-space depth**, because that is what oitWeight's falloff
@@ -253,6 +299,20 @@ fn blendFrag(in: BlendVarying) -> BlendTargets {
   out.reveal = vec4<f32>(alpha, 0.0, 0.0, alpha);
   return out;
 }
+
+/*
+ * **What a pane lets through, drawn from the sun into the tint map**: \`blendVert\` again, handed
+ * the light's raster matrix and the glass list, and this for the colour — \`glassShadow.ts\`'s
+ * paneTexel, the forward path's GLASS_TINT_FRAG in this language. Written against a white target
+ * with a multiplying blend and no depth, so every pane on a ray counts in any order.
+ */
+@fragment
+fn glassTintFrag(in: BlendVarying) -> @location(0) vec4<f32> {
+  let entry = materials[min(in.material, ${MATERIAL_SLOTS - 1}u)];
+  let c = clamp(abs(dot(normalize(in.normal), frame.lightDir.xyz)), 0.05, 1.0);
+  let passes = entry.extra.y * (1.0 - (0.04 + 0.96 * pow(1.0 - c, 5.0)));
+  return vec4<f32>(passes * entry.glassTint.xyz, 1.0 - entry.extra.z);
+}
 `;
 /**
  * The two targets composited over what the opaque half drew.
@@ -337,3 +397,28 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
   results[out + 3u] = resolved.z;
 }
 `;
+/**
+ * `glassShade` alone, as a dispatch, so it can be checked against `gpudriven/lit.ts`.
+ *
+ * Sixteen floats a case — own, seen, transmission, frost, tint, the view cosine, the glow, one
+ * spare — and four out, the colour and one spare.
+ */
+export const GLASS_SHADE_PARITY_WGSL = /* wgsl */ `
+@group(0) @binding(0) var<storage, read> cases: array<f32>;
+@group(0) @binding(1) var<storage, read_write> results: array<f32>;
+${GLASS_SHADE_WGSL}
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x * 16u + 15u >= arrayLength(&cases)) { return; }
+  let at = id.x * 16u;
+  let own = vec3<f32>(cases[at], cases[at + 1u], cases[at + 2u]);
+  let seen = vec3<f32>(cases[at + 3u], cases[at + 4u], cases[at + 5u]);
+  let tint = vec3<f32>(cases[at + 8u], cases[at + 9u], cases[at + 10u]);
+  let glow = vec3<f32>(cases[at + 12u], cases[at + 13u], cases[at + 14u]);
+  let shaded = glassShade(own, seen, cases[at + 6u], cases[at + 7u], tint, cases[at + 11u], glow);
+  let out = id.x * 4u;
+  results[out] = shaded.x;
+  results[out + 1u] = shaded.y;
+  results[out + 2u] = shaded.z;
+}
+`;

package/dist/render/shaders/gpudriven/cull.wgsl.d.ts

@@ -43,7 +43,7 @@ export declare const CULL_INSTANCES_WGSL = "\n@group(0) @binding(0) var<storage,
  * wall and is the whole reason the front half of the pipeline is reusable. A scene with nothing
  * blended runs this once and the filter costs it one comparison against a uniform.
  */
-export declare const LOD_CUT_WGSL = "\nstruct Params {\n  screenHeight: f32,\n  fovY: f32,\n  thresholdPixels: f32,\n  eyeX: f32,\n  eyeY: f32,\n  eyeZ: f32,\n  /** Non-zero to select the blended clusters, zero to select everything else. */\n  wantBlend: f32,\n};\n\nstruct Material {\n  /** rgb is the tint, w is the emissive gain. */\n  tint: vec4<f32>,\n  /** x is the roughness, y the specular reflectance, z the environment's and w the metalness. */\n  surface: vec4<f32>,\n  /** Base colour, normal, ORM and emissive programs; NO_PROGRAM where there is none. */\n  programs: vec4<u32>,\n  /** u scale, v scale, normal strength, occlusion strength. */\n  maps: vec4<f32>,\n  /** Roughness scale, metallic scale, the alpha cutoff, and non-zero where this one blends. */\n  orm: vec4<f32>,\n  /** The blended opacity, and three spare. */\n  extra: vec4<f32>,\n}\n\nconst NO_PROGRAM: u32 = 4294967295u;\n\n@group(0) @binding(0) var<storage, read> params: array<f32, 7>;\n/** Six floats a cluster: centre, radius, own error, parent error. */\n@group(0) @binding(1) var<storage, read> clusters: array<f32>;\n@group(0) @binding(2) var<storage, read_write> selected: array<u32>;\n/** Four words a cluster: index offset, index count, identifier, mesh. */\n@group(0) @binding(3) var<storage, read> clusterMeta: array<u32>;\n/** One word a mesh, nonzero where CULL_INSTANCES_WGSL found it wholly outside the view. */\n@group(0) @binding(4) var<storage, read> instanceHidden: array<u32>;\n/** One material a cluster, and the table it indexes. Both only to read one flag. */\n@group(0) @binding(5) var<storage, read> materialOf: array<u32>;\n@group(0) @binding(6) var<uniform> materials: array<Material, 64>;\n\nfn projectedError(error: f32, distance: f32, radius: f32, screenHeight: f32, fovY: f32) -> f32 {\n  let safe = max(max(distance, radius), 1e-4);\n  let scale = screenHeight / (2.0 * tan(fovY * 0.5));\n  return (error * scale) / safe;\n}\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i * 6u + 5u >= arrayLength(&clusters)) { return; }\n  /* A hidden mesh contributes nothing, so none of its clusters is in the cut at any level. */\n  if (instanceHidden[clusterMeta[i * 4u + 3u]] != 0u) {\n    selected[i] = 0u;\n    return;\n  }\n  /*\n   * **Which half of the frame this cluster belongs to, asked once.** The two halves are exclusive:\n   * a blended cluster is not in the opaque cut and an opaque one is not in the blended cut, so\n   * neither is drawn twice and neither is dropped. The flag is read through a uniform by an index\n   * that is the same for every cluster of a mesh, so the branch is as coherent as this shader gets.\n   */\n  let blended = materials[min(materialOf[i], 63u)].orm.w != 0.0;\n  if (blended != (params[6] != 0.0)) {\n    selected[i] = 0u;\n    return;\n  }\n  let screenHeight = params[0];\n  let fovY = params[1];\n  let threshold = params[2];\n  let eye = vec3<f32>(params[3], params[4], params[5]);\n\n  let centre = vec3<f32>(clusters[i * 6u], clusters[i * 6u + 1u], clusters[i * 6u + 2u]);\n  let radius = clusters[i * 6u + 3u];\n  let ownError = clusters[i * 6u + 4u];\n  let parentError = clusters[i * 6u + 5u];\n  let distance = length(centre - eye);\n\n  let own = projectedError(ownError, distance, radius, screenHeight, fovY);\n  let parent = projectedError(parentError, distance, radius, screenHeight, fovY);\n  /* Both halves: the first alone draws every ancestor too, the second alone draws nothing. */\n  selected[i] = select(0u, 1u, own <= threshold && parent > threshold);\n}\n";
+export declare const LOD_CUT_WGSL = "\nstruct Params {\n  screenHeight: f32,\n  fovY: f32,\n  thresholdPixels: f32,\n  eyeX: f32,\n  eyeY: f32,\n  eyeZ: f32,\n  /** Non-zero to select the blended clusters, zero to select everything else. */\n  wantBlend: f32,\n  /** Non-zero to keep, of those, only glass: what the light's glass pass draws. */\n  wantGlass: f32,\n};\n\nstruct Material {\n  /** rgb is the tint, w is the emissive gain. */\n  tint: vec4<f32>,\n  /** x is the roughness, y the specular reflectance, z the environment's and w the metalness. */\n  surface: vec4<f32>,\n  /** Base colour, normal, ORM and emissive programs; NO_PROGRAM where there is none. */\n  programs: vec4<u32>,\n  /** u scale, v scale, normal strength, occlusion strength. */\n  maps: vec4<f32>,\n  /** Roughness scale, metallic scale, the alpha cutoff, and non-zero where this one blends. */\n  orm: vec4<f32>,\n  /** The blended opacity, the glass's transmission and frost, and one spare. */\n  extra: vec4<f32>,\n  /** The glass's tint, white where the material is not glass, and one spare. */\n  glassTint: vec4<f32>,\n}\n\nconst NO_PROGRAM: u32 = 4294967295u;\n\n@group(0) @binding(0) var<storage, read> params: array<f32, 8>;\n/** Six floats a cluster: centre, radius, own error, parent error. */\n@group(0) @binding(1) var<storage, read> clusters: array<f32>;\n@group(0) @binding(2) var<storage, read_write> selected: array<u32>;\n/** Four words a cluster: index offset, index count, identifier, mesh. */\n@group(0) @binding(3) var<storage, read> clusterMeta: array<u32>;\n/** One word a mesh, nonzero where CULL_INSTANCES_WGSL found it wholly outside the view. */\n@group(0) @binding(4) var<storage, read> instanceHidden: array<u32>;\n/** One material a cluster, and the table it indexes. Both only to read one flag. */\n@group(0) @binding(5) var<storage, read> materialOf: array<u32>;\n@group(0) @binding(6) var<uniform> materials: array<Material, 64>;\n\nfn projectedError(error: f32, distance: f32, radius: f32, screenHeight: f32, fovY: f32) -> f32 {\n  let safe = max(max(distance, radius), 1e-4);\n  let scale = screenHeight / (2.0 * tan(fovY * 0.5));\n  return (error * scale) / safe;\n}\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i * 6u + 5u >= arrayLength(&clusters)) { return; }\n  /* A hidden mesh contributes nothing, so none of its clusters is in the cut at any level. */\n  if (instanceHidden[clusterMeta[i * 4u + 3u]] != 0u) {\n    selected[i] = 0u;\n    return;\n  }\n  /*\n   * **Which half of the frame this cluster belongs to, asked once.** The two halves are exclusive:\n   * a blended cluster is not in the opaque cut and an opaque one is not in the blended cut, so\n   * neither is drawn twice and neither is dropped. The flag is read through a uniform by an index\n   * that is the same for every cluster of a mesh, so the branch is as coherent as this shader gets.\n   */\n  let material = materials[min(materialOf[i], 63u)];\n  let blended = material.orm.w != 0.0;\n  if (blended != (params[6] != 0.0)) {\n    selected[i] = 0u;\n    return;\n  }\n  /* The light's glass pass: a blended surface that is not glass casts nothing, as on the forward\n     path, so only a material letting light through is kept. */\n  if (params[7] != 0.0 && material.extra.y <= 0.0) {\n    selected[i] = 0u;\n    return;\n  }\n  let screenHeight = params[0];\n  let fovY = params[1];\n  let threshold = params[2];\n  let eye = vec3<f32>(params[3], params[4], params[5]);\n\n  let centre = vec3<f32>(clusters[i * 6u], clusters[i * 6u + 1u], clusters[i * 6u + 2u]);\n  let radius = clusters[i * 6u + 3u];\n  let ownError = clusters[i * 6u + 4u];\n  let parentError = clusters[i * 6u + 5u];\n  let distance = length(centre - eye);\n\n  let own = projectedError(ownError, distance, radius, screenHeight, fovY);\n  let parent = projectedError(parentError, distance, radius, screenHeight, fovY);\n  /* Both halves: the first alone draws every ancestor too, the second alone draws nothing. */\n  selected[i] = select(0u, 1u, own <= threshold && parent > threshold);\n}\n";
 /**
  * The pyramid's base level, copied out of the depth attachment a phase drew into.
  *

package/dist/render/shaders/gpudriven/cull.wgsl.js

@@ -100,9 +100,11 @@ struct Params {
   eyeZ: f32,
   /** Non-zero to select the blended clusters, zero to select everything else. */
   wantBlend: f32,
+  /** Non-zero to keep, of those, only glass: what the light's glass pass draws. */
+  wantGlass: f32,
 };
 ${MATERIAL_TABLE_WGSL}
-@group(0) @binding(0) var<storage, read> params: array<f32, 7>;
+@group(0) @binding(0) var<storage, read> params: array<f32, 8>;
 /** Six floats a cluster: centre, radius, own error, parent error. */
 @group(0) @binding(1) var<storage, read> clusters: array<f32>;
 @group(0) @binding(2) var<storage, read_write> selected: array<u32>;
@@ -135,11 +137,18 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
    * neither is drawn twice and neither is dropped. The flag is read through a uniform by an index
    * that is the same for every cluster of a mesh, so the branch is as coherent as this shader gets.
    */
-  let blended = materials[min(materialOf[i], ${MATERIAL_SLOTS - 1}u)].orm.w != 0.0;
+  let material = materials[min(materialOf[i], ${MATERIAL_SLOTS - 1}u)];
+  let blended = material.orm.w != 0.0;
   if (blended != (params[6] != 0.0)) {
     selected[i] = 0u;
     return;
   }
+  /* The light's glass pass: a blended surface that is not glass casts nothing, as on the forward
+     path, so only a material letting light through is kept. */
+  if (params[7] != 0.0 && material.extra.y <= 0.0) {
+    selected[i] = 0u;
+    return;
+  }
   let screenHeight = params[0];
   let fovY = params[1];
   let threshold = params[2];

package/dist/render/shaders/gpudriven/materialTable.wgsl.d.ts

@@ -22,4 +22,4 @@
  */
 export declare const MATERIAL_SLOTS = 64;
 /** The struct and the sentinel, for any module that binds the table. */
-export declare const MATERIAL_TABLE_WGSL = "\nstruct Material {\n  /** rgb is the tint, w is the emissive gain. */\n  tint: vec4<f32>,\n  /** x is the roughness, y the specular reflectance, z the environment's and w the metalness. */\n  surface: vec4<f32>,\n  /** Base colour, normal, ORM and emissive programs; NO_PROGRAM where there is none. */\n  programs: vec4<u32>,\n  /** u scale, v scale, normal strength, occlusion strength. */\n  maps: vec4<f32>,\n  /** Roughness scale, metallic scale, the alpha cutoff, and non-zero where this one blends. */\n  orm: vec4<f32>,\n  /** The blended opacity, and three spare. */\n  extra: vec4<f32>,\n}\n\nconst NO_PROGRAM: u32 = 4294967295u;\n";
+export declare const MATERIAL_TABLE_WGSL = "\nstruct Material {\n  /** rgb is the tint, w is the emissive gain. */\n  tint: vec4<f32>,\n  /** x is the roughness, y the specular reflectance, z the environment's and w the metalness. */\n  surface: vec4<f32>,\n  /** Base colour, normal, ORM and emissive programs; NO_PROGRAM where there is none. */\n  programs: vec4<u32>,\n  /** u scale, v scale, normal strength, occlusion strength. */\n  maps: vec4<f32>,\n  /** Roughness scale, metallic scale, the alpha cutoff, and non-zero where this one blends. */\n  orm: vec4<f32>,\n  /** The blended opacity, the glass's transmission and frost, and one spare. */\n  extra: vec4<f32>,\n  /** The glass's tint, white where the material is not glass, and one spare. */\n  glassTint: vec4<f32>,\n}\n\nconst NO_PROGRAM: u32 = 4294967295u;\n";

package/dist/render/shaders/gpudriven/materialTable.wgsl.js

@@ -35,8 +35,10 @@ struct Material {
   maps: vec4<f32>,
   /** Roughness scale, metallic scale, the alpha cutoff, and non-zero where this one blends. */
   orm: vec4<f32>,
-  /** The blended opacity, and three spare. */
+  /** The blended opacity, the glass's transmission and frost, and one spare. */
   extra: vec4<f32>,
+  /** The glass's tint, white where the material is not glass, and one spare. */
+  glassTint: vec4<f32>,
 }
 
 const NO_PROGRAM: u32 = ${DECODE_NO_PROGRAM}u;

package/dist/render/shaders/gpudriven/shade.wgsl.js

@@ -8,6 +8,7 @@ import { MATERIAL_SLOTS, MATERIAL_TABLE_WGSL } from './materialTable.wgsl.js';
 import { MESH_TRANSFORM_WGSL } from './meshTransform.wgsl.js';
 import { ENVIRONMENT_WGSL } from './environment.wgsl.js';
 import { SHADE_SHADOW_WGSL } from './shadow.wgsl.js';
+import { SUN_GLASS_WGSL } from './sunGlass.wgsl.js';
 /**
  * Rebuilding a pixel's surface from the triangle it recorded, on the device.
  *
@@ -509,6 +510,14 @@ struct Job {
 @group(0) @binding(12) var environmentMap: texture_2d_array<f32>;
 @group(0) @binding(13) var environmentSampler: sampler;
 ${decodeResourcesWgsl({ group: 0, latents: 14, clampSampler: 15, repeatSampler: 16, nodes: 17, weights: 18 })}
+/*
+ * **What the sun keeps through glass: the nearest pane's depth and what the panes let through**,
+ * which the pass draws from the sun after its opaque map. Where no material is glass the depth is
+ * the opaque map again and the tint a single white texel, which sunGlassAt reads as none.
+ */
+@group(0) @binding(19) var glassDepthMap: texture_depth_2d;
+@group(0) @binding(20) var glassTints: texture_2d<f32>;
+@group(0) @binding(21) var glassSampler: sampler;
 
 fn decodeLatentSize() -> f32 {
   return frame.size.w;
@@ -540,6 +549,45 @@ fn shadowDepthAt(u: f32, v: f32) -> f32 {
   return textureLoad(shadowMap, vec2<i32>(x, y), 0);
 }
 ${SHADE_SHADOW_WGSL}
+
+/* sunGlass.wgsl.ts's three reads, as the opaque map is read: nearest by integer coordinate. */
+fn glassDepthAt(u: f32, v: f32) -> f32 {
+  let size = frame.shadow.y;
+  let x = i32(clamp(floor(u * size), 0.0, size - 1.0));
+  let y = i32(clamp(floor(v * size), 0.0, size - 1.0));
+  return textureLoad(glassDepthMap, vec2<i32>(x, y), 0);
+}
+
+fn glassTintTexel(u: f32, v: f32) -> vec4<f32> {
+  let size = f32(textureDimensions(glassTints, 0).x);
+  let x = i32(clamp(floor(u * size), 0.0, size - 1.0));
+  let y = i32(clamp(floor(v * size), 0.0, size - 1.0));
+  return textureLoad(glassTints, vec2<i32>(x, y), 0);
+}
+
+/* The tint over a spread, from the chain: the level whose texel is the spread's width. */
+fn glassTintAround(u: f32, v: f32, radius: f32) -> vec4<f32> {
+  let size = f32(textureDimensions(glassTints, 0).x);
+  return textureSampleLevel(glassTints, glassSampler, vec2<f32>(u, v), log2(max(radius * size, 1.0)));
+}
+${SUN_GLASS_WGSL}
+
+/*
+ * The sun's colour at this receiver after the panes between it and the sun: white where no glass
+ * cast, and faded with the opaque shadow's own strength. The map's scale in metres comes off the
+ * light's matrix, which is orthographic: a compute invocation has no derivatives to take it from.
+ */
+fn sunGlassAt(lightPos: vec3<f32>) -> vec3<f32> {
+  if (textureDimensions(glassTints, 0).x <= 1u || frame.shadow.x <= 0.0) { return vec3<f32>(1.0); }
+  let m = frame.lightViewProj;
+  var settings: SunGlassSettings;
+  settings.mapSize = frame.shadow.y;
+  settings.depthSpan = frame.shadow.z;
+  settings.uvPerMetre = 0.5 * length(vec3<f32>(m[0][0], m[1][0], m[2][0]));
+  settings.taps = frame.shadowLimits.y;
+  let tint = sunGlass(lightPos.x * 0.5 + 0.5, lightPos.y * 0.5 + 0.5, lightPos.z, settings);
+  return mix(vec3<f32>(1.0), tint, frame.shadow.x);
+}
 ${ENVIRONMENT_WGSL}
 ${FOG_WGSL}
 
@@ -732,7 +780,8 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
 
   var room: LitEnvironment;
   room.lightDir = frame.lightDir.xyz;
-  room.lightColour = frame.lightColour.xyz;
+  /* The sun's colour through whatever glass stands between it and here, as flat/main.ts's is. */
+  room.lightColour = frame.lightColour.xyz * sunGlassAt(lightPos);
   room.sky = frame.sky.xyz;
   room.ground = frame.ground.xyz;
   /*

package/dist/render/shaders/gpudriven/sunGlass.wgsl.d.ts

@@ -0,0 +1,9 @@
+export declare const SUN_GLASS_WGSL: string;
+/**
+ * `sunGlass` over maps held in storage buffers, read as the reference reads them, so the whole
+ * lookup can be compared with `glassTintAt` rather than only the arithmetic between the reads.
+ *
+ * Four floats a case in — u, v, the receiver's depth, one spare — and four out, the tint and one
+ * spare. The config is the map's size, the depth span, map units a metre, and the tap count.
+ */
+export declare const SUN_GLASS_PARITY_WGSL: string;

package/dist/render/shaders/gpudriven/sunGlass.wgsl.js

@@ -0,0 +1,133 @@
+/**
+ * The sun through glass for the device: `gpudriven/sunGlass.ts`'s `glassTintAt`, term for term, as
+ * the text the shading pass and the parity entry point both include.
+ *
+ * **The reads are the including module's**, as `SHADE_SHADOW_WGSL`'s are: `glassDepthAt(u, v)` the
+ * nearest pane's depth, `glassTintTexel(u, v)` the tint at the finest level, and
+ * `glassTintAround(u, v, radius)` the tint averaged over a spread of that radius. The shading pass
+ * answers the last from the tint's mip chain; the parity entry answers it with the reference's own
+ * box average, so everything around the reads is checked as it stands. Every constant is the
+ * reference's, interpolated rather than restated.
+ */
+import { FROST_RADIUS_CAP, FROST_SPREAD } from '../../glassShadow.js';
+import { SHADOW_DEPTH_BIAS, SHADOW_PCF_OFFSETS, SHADOW_TEXEL_SCALE, } from '../../gpudriven/shadow.js';
+import { SHADE_SHADOW_WGSL } from './shadow.wgsl.js';
+export const SUN_GLASS_WGSL = /* wgsl */ `
+struct SunGlassSettings {
+  mapSize: f32,
+  depthSpan: f32,
+  uvPerMetre: f32,
+  taps: f32,
+}
+
+/*
+ * A coarse texel with the open ground's white taken back out, by how milky the pane at the
+ * receiver is: the pane's colour and its share of the texel. glassShadow.ts's unmixTint.
+ */
+fn sunGlassUnmix(mip: vec4<f32>, centreClarity: f32) -> vec4<f32> {
+  if (centreClarity >= 1.0) { return vec4<f32>(mip.xyz, 1.0); }
+  let share = clamp((1.0 - mip.w) / (1.0 - centreClarity), 0.0, 1.0);
+  if (share <= 0.0) { return vec4<f32>(1.0, 1.0, 1.0, 0.0); }
+  let colour = clamp((mip.xyz - vec3<f32>(1.0 - share)) / share, vec3<f32>(0.0), vec3<f32>(1.0));
+  return vec4<f32>(colour, share);
+}
+
+/* What the sun keeps through glass at map position (u, v) and light depth "depth". */
+fn sunGlass(u: f32, v: f32, depth: f32, settings: SunGlassSettings) -> vec3<f32> {
+  if (u < 0.0 || u > 1.0 || v < 0.0 || v > 1.0) { return vec3<f32>(1.0); }
+  let texel = ${SHADOW_TEXEL_SCALE.toFixed(4)} / settings.mapSize;
+  let bias = ${SHADOW_DEPTH_BIAS.toFixed(4)} / settings.depthSpan;
+  let taps = min(u32(settings.taps), ${SHADOW_PCF_OFFSETS.length}u);
+  let clarity = glassTintTexel(u, v).w;
+  let behind = max(depth - glassDepthAt(u, v), 0.0) * settings.depthSpan;
+  let spread = (1.0 - clarity) * ${FROST_SPREAD.toFixed(6)} * behind * settings.uvPerMetre;
+  let radius = min(max(texel, spread), texel * ${FROST_RADIUS_CAP.toFixed(1)});
+
+  var cover = 0.0;
+  var colour = vec3<f32>(0.0);
+  var found = 0.0;
+  for (var i = 0u; i < taps; i = i + 1u) {
+    let offset = SHADOW_TAPS[i];
+    /* The outline: a tap counts the pane only where the receiver is behind it, by the bias. */
+    if (depth > glassDepthAt(u + offset.x * texel, v + offset.y * texel) + bias) {
+      cover = cover + 1.0;
+    }
+    /* The colour: the spread's taps, each an average, unmixed and weighed by the pane's share. */
+    let pane = sunGlassUnmix(glassTintAround(u + offset.x * radius, v + offset.y * radius, radius), clarity);
+    colour = colour + pane.xyz * pane.w;
+    found = found + pane.w;
+  }
+  let mixed = select(vec3<f32>(1.0), colour / max(found, 1e-6), found > 0.0);
+  return mix(vec3<f32>(1.0), mixed, cover / f32(max(taps, 1u)));
+}
+`;
+/**
+ * `sunGlass` over maps held in storage buffers, read as the reference reads them, so the whole
+ * lookup can be compared with `glassTintAt` rather than only the arithmetic between the reads.
+ *
+ * Four floats a case in — u, v, the receiver's depth, one spare — and four out, the tint and one
+ * spare. The config is the map's size, the depth span, map units a metre, and the tap count.
+ */
+export const SUN_GLASS_PARITY_WGSL = /* wgsl */ `
+@group(0) @binding(0) var<storage, read> depths: array<f32>;
+@group(0) @binding(1) var<storage, read> tints: array<f32>;
+@group(0) @binding(2) var<storage, read> cases: array<f32>;
+@group(0) @binding(3) var<storage, read> config: array<f32>;
+@group(0) @binding(4) var<storage, read_write> results: array<f32>;
+
+/* The opaque lookup's own read, which this entry never calls: included only for its tap table. */
+fn shadowDepthAt(u: f32, v: f32) -> f32 { return 1.0; }
+${SHADE_SHADOW_WGSL}
+
+fn glassIndex(u: f32, v: f32) -> u32 {
+  let size = config[0];
+  let x = u32(clamp(floor(u * size), 0.0, size - 1.0));
+  let y = u32(clamp(floor(v * size), 0.0, size - 1.0));
+  return y * u32(size) + x;
+}
+
+fn glassDepthAt(u: f32, v: f32) -> f32 {
+  return depths[glassIndex(u, v)];
+}
+
+fn glassTintTexel(u: f32, v: f32) -> vec4<f32> {
+  let at = glassIndex(u, v) * 4u;
+  return vec4<f32>(tints[at], tints[at + 1u], tints[at + 2u], tints[at + 3u]);
+}
+
+/* The reference's coarse read: the average of every texel within the radius. */
+fn glassTintAround(u: f32, v: f32, radius: f32) -> vec4<f32> {
+  let size = config[0];
+  let reach = radius * size;
+  let x0 = u32(max(0.0, floor(u * size - reach)));
+  let x1 = u32(min(size - 1.0, floor(u * size + reach)));
+  let y0 = u32(max(0.0, floor(v * size - reach)));
+  let y1 = u32(min(size - 1.0, floor(v * size + reach)));
+  var sum = vec4<f32>(0.0);
+  var n = 0.0;
+  for (var y = y0; y <= y1; y = y + 1u) {
+    for (var x = x0; x <= x1; x = x + 1u) {
+      let at = (y * u32(size) + x) * 4u;
+      sum = sum + vec4<f32>(tints[at], tints[at + 1u], tints[at + 2u], tints[at + 3u]);
+      n = n + 1.0;
+    }
+  }
+  return sum / max(n, 1.0);
+}
+${SUN_GLASS_WGSL}
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x * 4u + 3u >= arrayLength(&cases)) { return; }
+  var settings: SunGlassSettings;
+  settings.mapSize = config[0];
+  settings.depthSpan = config[1];
+  settings.uvPerMetre = config[2];
+  settings.taps = config[3];
+  let at = id.x * 4u;
+  let tint = sunGlass(cases[at], cases[at + 1u], cases[at + 2u], settings);
+  results[at] = tint.x;
+  results[at + 1u] = tint.y;
+  results[at + 2u] = tint.z;
+}
+`;

package/dist/render/shaders/lightVolume.js

@@ -46,6 +46,7 @@
  *   the window it came through, and without it a barred floor under a smooth shaft is two
  *   halves of one frame disagreeing about the same light.
  */
+import { SUN_DYNAMIC_LAYER, SUN_PEELED_LAYER, SUN_STATIC_LAYER } from '../shadowMap.js';
 import { resolveConditionals } from './conditionals.js';
 export const LIGHT_VOLUME_VERT = `#version 300 es
 precision highp float;
@@ -143,9 +144,8 @@ uniform vec3 uDustOffset;
 uniform float uSunShadow;
 uniform mat4 uLightViewProj;
 uniform float uShadowMapSize;
-uniform sampler2D uStaticShadowMap;
-uniform sampler2D uPeeledShadowMap;
-uniform sampler2D uDynamicShadowMap;
+/* The sun's static, moving and peeled maps, as layers of one array: see shadowMap.ts. */
+uniform highp sampler2DArray uSunShadows;
 uniform int uPeeledShadowEnabled;
 #endif
 
@@ -308,11 +308,11 @@ float sunReach(vec3 worldPos) {
   if (edgeFade <= 0.0) return 1.0;
 
   float compare = p.z - BIAS;
-  float blocked = occlusion(textureLod(uStaticShadowMap, p.xy, 0.0).r, compare);
+  float blocked = occlusion(textureLod(uSunShadows, vec3(p.xy, ${SUN_STATIC_LAYER}.0), 0.0).r, compare);
   if (uPeeledShadowEnabled != 0) {
-    blocked = max(blocked, occlusion(textureLod(uPeeledShadowMap, p.xy, 0.0).r, compare));
+    blocked = max(blocked, occlusion(textureLod(uSunShadows, vec3(p.xy, ${SUN_PEELED_LAYER}.0), 0.0).r, compare));
   }
-  blocked = max(blocked, occlusion(textureLod(uDynamicShadowMap, p.xy, 0.0).r, compare));
+  blocked = max(blocked, occlusion(textureLod(uSunShadows, vec3(p.xy, ${SUN_DYNAMIC_LAYER}.0), 0.0).r, compare));
   return mix(1.0, 1.0 - blocked, uSunShadow * edgeFade);
 }
 #endif

package/dist/render/shaders/octahedralResolve.d.ts

@@ -23,3 +23,11 @@ export declare const OCTAHEDRAL_RESOLVE_VERT = "#version 300 es\nvoid main() {\n
  * redeclaration and GLSL rejects the whole shader.
  */
 export declare const OCTAHEDRAL_RESOLVE_FRAG = "#version 300 es\nprecision highp float;\n\n/** The face the bake just rendered, as a depth texture. */\nuniform highp sampler2D uFace;\n/** That face's world-to-face rotation. See pointShadowFaceRotation. */\nuniform mat3 uFaceRotation;\n/** Which of the six this pass is resolving. Every other texel discards. */\nuniform int uFaceIndex;\nuniform float uFar;\nuniform float uNear;\n/** The octahedral map's edge, so this needs no viewport query. */\nuniform float uEdge;\n\nvec2 octEncode(vec3 d) {\n  vec3 n = d / (abs(d.x) + abs(d.y) + abs(d.z));\n  vec2 p = n.z >= 0.0\n    ? n.xy\n    : (1.0 - abs(vec2(n.y, n.x))) * vec2(n.x >= 0.0 ? 1.0 : -1.0, n.y >= 0.0 ? 1.0 : -1.0);\n  return p * 0.5 + 0.5;\n}\n\nvec3 octDecode(vec2 uv) {\n  vec2 f = uv * 2.0 - 1.0;\n  vec3 n = vec3(f.x, f.y, 1.0 - abs(f.x) - abs(f.y));\n  float t = max(-n.z, 0.0);\n  n.x += n.x >= 0.0 ? -t : t;\n  n.y += n.y >= 0.0 ? -t : t;\n  return normalize(n);\n}\n\nvec2 octWrapUv(vec2 uv) {\n  vec2 f = uv * 2.0 - 1.0;\n  if (f.x < -1.0 || f.x > 1.0) {\n    f.x = (f.x > 0.0 ? 2.0 : -2.0) - f.x;\n    f.y = -f.y;\n  }\n  if (f.y < -1.0 || f.y > 1.0) {\n    f.y = (f.y > 0.0 ? 2.0 : -2.0) - f.y;\n    f.x = -f.x;\n  }\n  return f * 0.5 + 0.5;\n}\n\nvec2 octInsetUv(vec3 d, float edge) {\n  return (octEncode(d) * (edge - 2.0) + 1.0) / edge;\n}\n\nvec3 octInsetDir(vec2 uv, float edge) {\n  return octDecode(octWrapUv((uv * edge - 1.0) / (edge - 2.0)));\n}\n\nvoid main() {\n  vec3 d = octDecode(gl_FragCoord.xy / uEdge);\n\n  /*\n   * Which face owns this texel. The tie-breaking is x, then y, then z, and it has to match the\n   * CPU's exactly or a sliver of texels along a boundary belongs to two faces or to none.\n   */\n  vec3 a = abs(d);\n  int face;\n  if (a.x >= a.y && a.x >= a.z) face = d.x >= 0.0 ? 0 : 1;\n  else if (a.y >= a.z) face = d.y >= 0.0 ? 2 : 3;\n  else face = d.z >= 0.0 ? 4 : 5;\n  if (face != uFaceIndex) discard;\n\n  /* lookAt looks down -z, so a direction inside this face has a negative z here. */\n  vec3 v = uFaceRotation * d;\n  float forward = -v.z;\n  vec2 faceUv = (v.xy / forward) * 0.5 + 0.5;\n\n  /*\n   * textureLod at level zero rather than plain texture. The scratch carries one storage level and\n   * NEAREST filtering so the fetch is identical, and this call sits after a discard \u2014 which is\n   * non-uniform control flow, where an implicit derivative is undefined in GLSL and rejected\n   * outright in WGSL. AGENTS.md, 2026-08-07.\n   */\n  float stored = textureLod(uFace, faceUv, 0.0).r;\n  if (stored >= 0.9999) {\n    /* Nothing was rendered along this direction, so the stored radius is the far plane. */\n    gl_FragDepth = 1.0;\n    return;\n  }\n  float ndc = stored * 2.0 - 1.0;\n  float faceLocalZ = (2.0 * uFar * uNear) / (uFar + uNear - ndc * (uFar - uNear));\n  /* d is a unit vector, so forward is its cosine to the axis and this is the true radius. */\n  gl_FragDepth = clamp((faceLocalZ / forward) / uFar, 0.0, 1.0);\n}";
+/**
+ * One face of a lamp's glass tint into its region of the tint layer: the depth resolve's region,
+ * and a colour copied rather than a depth decoded.
+ *
+ * **Nearest, at level zero**, like the depth beside it: the tint's outline has to land on the
+ * glass depth's texels, and a filtered copy would smear a pane's colour a texel past its edge.
+ */
+export declare const OCTAHEDRAL_RESOLVE_TINT_FRAG = "#version 300 es\nprecision highp float;\n\n/** The face the bake just tinted, as colour. */\nuniform highp sampler2D uFace;\nuniform mat3 uFaceRotation;\nuniform int uFaceIndex;\nuniform float uEdge;\n\nout vec4 outTint;\n\nvec2 octEncode(vec3 d) {\n  vec3 n = d / (abs(d.x) + abs(d.y) + abs(d.z));\n  vec2 p = n.z >= 0.0\n    ? n.xy\n    : (1.0 - abs(vec2(n.y, n.x))) * vec2(n.x >= 0.0 ? 1.0 : -1.0, n.y >= 0.0 ? 1.0 : -1.0);\n  return p * 0.5 + 0.5;\n}\n\nvec3 octDecode(vec2 uv) {\n  vec2 f = uv * 2.0 - 1.0;\n  vec3 n = vec3(f.x, f.y, 1.0 - abs(f.x) - abs(f.y));\n  float t = max(-n.z, 0.0);\n  n.x += n.x >= 0.0 ? -t : t;\n  n.y += n.y >= 0.0 ? -t : t;\n  return normalize(n);\n}\n\nvec2 octWrapUv(vec2 uv) {\n  vec2 f = uv * 2.0 - 1.0;\n  if (f.x < -1.0 || f.x > 1.0) {\n    f.x = (f.x > 0.0 ? 2.0 : -2.0) - f.x;\n    f.y = -f.y;\n  }\n  if (f.y < -1.0 || f.y > 1.0) {\n    f.y = (f.y > 0.0 ? 2.0 : -2.0) - f.y;\n    f.x = -f.x;\n  }\n  return f * 0.5 + 0.5;\n}\n\nvec2 octInsetUv(vec3 d, float edge) {\n  return (octEncode(d) * (edge - 2.0) + 1.0) / edge;\n}\n\nvec3 octInsetDir(vec2 uv, float edge) {\n  return octDecode(octWrapUv((uv * edge - 1.0) / (edge - 2.0)));\n}\n\nvoid main() {\n  vec3 d = octDecode(gl_FragCoord.xy / uEdge);\n\n  /*\n   * Which face owns this texel. The tie-breaking is x, then y, then z, and it has to match the\n   * CPU's exactly or a sliver of texels along a boundary belongs to two faces or to none.\n   */\n  vec3 a = abs(d);\n  int face;\n  if (a.x >= a.y && a.x >= a.z) face = d.x >= 0.0 ? 0 : 1;\n  else if (a.y >= a.z) face = d.y >= 0.0 ? 2 : 3;\n  else face = d.z >= 0.0 ? 4 : 5;\n  if (face != uFaceIndex) discard;\n\n  /* lookAt looks down -z, so a direction inside this face has a negative z here. */\n  vec3 v = uFaceRotation * d;\n  float forward = -v.z;\n  vec2 faceUv = (v.xy / forward) * 0.5 + 0.5;\n  outTint = textureLod(uFace, faceUv, 0.0);\n}";

package/dist/render/shaders/octahedralResolve.js

@@ -10,6 +10,29 @@ void main() {
   vec2 p = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2));
   gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);
 }`;
+/**
+ * Which cube face owns this octahedral texel, and where in that face it looks: `d`, `forward` and
+ * `faceUv`, with every texel another face owns discarded. **One text for both resolves**, depth
+ * and tint, because the tie-breaking has to agree with itself as well as with the CPU: a sliver
+ * of texels given to one face's depth and another face's colour is a tinted seam.
+ */
+const FACE_REGION = `  vec3 d = octDecode(gl_FragCoord.xy / uEdge);
+
+  /*
+   * Which face owns this texel. The tie-breaking is x, then y, then z, and it has to match the
+   * CPU's exactly or a sliver of texels along a boundary belongs to two faces or to none.
+   */
+  vec3 a = abs(d);
+  int face;
+  if (a.x >= a.y && a.x >= a.z) face = d.x >= 0.0 ? 0 : 1;
+  else if (a.y >= a.z) face = d.y >= 0.0 ? 2 : 3;
+  else face = d.z >= 0.0 ? 4 : 5;
+  if (face != uFaceIndex) discard;
+
+  /* lookAt looks down -z, so a direction inside this face has a negative z here. */
+  vec3 v = uFaceRotation * d;
+  float forward = -v.z;
+  vec2 faceUv = (v.xy / forward) * 0.5 + 0.5;`;
 /**
  * One cube face into its region of an octahedral map, as linear radial distance.
  *
@@ -44,23 +67,7 @@ uniform float uEdge;
 ${OCTAHEDRAL_GLSL}
 
 void main() {
-  vec3 d = octDecode(gl_FragCoord.xy / uEdge);
-
-  /*
-   * Which face owns this texel. The tie-breaking is x, then y, then z, and it has to match the
-   * CPU's exactly or a sliver of texels along a boundary belongs to two faces or to none.
-   */
-  vec3 a = abs(d);
-  int face;
-  if (a.x >= a.y && a.x >= a.z) face = d.x >= 0.0 ? 0 : 1;
-  else if (a.y >= a.z) face = d.y >= 0.0 ? 2 : 3;
-  else face = d.z >= 0.0 ? 4 : 5;
-  if (face != uFaceIndex) discard;
-
-  /* lookAt looks down -z, so a direction inside this face has a negative z here. */
-  vec3 v = uFaceRotation * d;
-  float forward = -v.z;
-  vec2 faceUv = (v.xy / forward) * 0.5 + 0.5;
+${FACE_REGION}
 
   /*
    * textureLod at level zero rather than plain texture. The scratch carries one storage level and
@@ -79,3 +86,27 @@ void main() {
   /* d is a unit vector, so forward is its cosine to the axis and this is the true radius. */
   gl_FragDepth = clamp((faceLocalZ / forward) / uFar, 0.0, 1.0);
 }`;
+/**
+ * One face of a lamp's glass tint into its region of the tint layer: the depth resolve's region,
+ * and a colour copied rather than a depth decoded.
+ *
+ * **Nearest, at level zero**, like the depth beside it: the tint's outline has to land on the
+ * glass depth's texels, and a filtered copy would smear a pane's colour a texel past its edge.
+ */
+export const OCTAHEDRAL_RESOLVE_TINT_FRAG = `#version 300 es
+precision highp float;
+
+/** The face the bake just tinted, as colour. */
+uniform highp sampler2D uFace;
+uniform mat3 uFaceRotation;
+uniform int uFaceIndex;
+uniform float uEdge;
+
+out vec4 outTint;
+
+${OCTAHEDRAL_GLSL}
+
+void main() {
+${FACE_REGION}
+  outTint = textureLod(uFace, faceUv, 0.0);
+}`;

package/dist/render/shaders/recon/lateDepth.wgsl.d.ts

@@ -0,0 +1 @@
+export declare const LATE_DEPTH_WGSL: string;

package/dist/render/shaders/recon/lateDepth.wgsl.js

@@ -0,0 +1,44 @@
+/**
+ * The render's depth, taken up to the output size for the draws that land after the upscale.
+ *
+ * **The nearest of the four render texels around each output pixel**, so a translucent draw is
+ * never let through an opaque edge the render did cover. What it gives up: where a translucent
+ * surface crosses an opaque silhouette, the edge steps at the render's resolution.
+ *
+ * Hand-written, and built by concatenation rather than a template literal: the reconstruction's
+ * passes have no WebGL2 twin (the AGENTS.md exception for them), and a `${}` inside WGSL source is
+ * the thing that rule forbids.
+ */
+import { REVERSED_DEPTH } from '../../depthConvention.js';
+/** The nearer of two stored depths: the larger in a reversed buffer. */
+const NEARER = REVERSED_DEPTH ? 'max' : 'min';
+/** Where the search for the nearest starts: the far plane. */
+const FARTHEST = REVERSED_DEPTH ? '0.0' : '1.0';
+export const LATE_DEPTH_WGSL = '@group(0) @binding(0) var source: texture_depth_2d;\n' +
+    '@group(0) @binding(1) var<uniform> sizes: vec4<f32>;\n' +
+    '\n' +
+    '@vertex\n' +
+    'fn lateDepthVert(@builtin(vertex_index) index: u32) -> @builtin(position) vec4<f32> {\n' +
+    '  let x = f32((index << 1u) & 2u);\n' +
+    '  let y = f32(index & 2u);\n' +
+    '  return vec4<f32>(x * 2.0 - 1.0, 1.0 - y * 2.0, 0.0, 1.0);\n' +
+    '}\n' +
+    '\n' +
+    '@fragment\n' +
+    'fn lateDepthFrag(@builtin(position) at: vec4<f32>) -> @builtin(frag_depth) f32 {\n' +
+    '  let centre = at.xy * sizes.xy / sizes.zw - vec2<f32>(0.5);\n' +
+    '  let base = vec2<i32>(floor(centre));\n' +
+    '  let top = vec2<i32>(sizes.xy) - vec2<i32>(1);\n' +
+    '  var nearest = ' +
+    FARTHEST +
+    ';\n' +
+    '  for (var y = 0; y < 2; y += 1) {\n' +
+    '    for (var x = 0; x < 2; x += 1) {\n' +
+    '      let texel = clamp(base + vec2<i32>(x, y), vec2<i32>(0), top);\n' +
+    '      nearest = ' +
+    NEARER +
+    '(nearest, textureLoad(source, texel, 0));\n' +
+    '    }\n' +
+    '  }\n' +
+    '  return nearest;\n' +
+    '}\n';

package/dist/render/shaders/recon/motion.wgsl.d.ts

@@ -41,4 +41,4 @@ export declare const MOTION_DRAW_STRIDE = 256;
 export declare const MOTION_DRAW_FLOATS = 32;
 /** The motion target's format. Half float holds a uv to a hundredth of a pixel and a view depth. */
 export declare const MOTION_TARGET_FORMAT: GPUTextureFormat;
-export declare const RECON_MOTION_WGSL = "\nstruct MotionFrame {\n  /* The scene's own clip transform, with the generated shaders' y negation already folded in. */\n  raster: mat4x4<f32>,\n  /* This frame's and last frame's view-projections, unjittered, in the matrices' own convention. */\n  viewProj: mat4x4<f32>,\n  previousViewProj: mat4x4<f32>,\n}\n\nstruct MotionDraw {\n  model: mat4x4<f32>,\n  previousModel: mat4x4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> frame: MotionFrame;\n@group(0) @binding(1) var<uniform> draw: MotionDraw;\n\nstruct Varyings {\n  @builtin(position) clip: vec4<f32>,\n  /* Clip positions rather than uv: an interpolator divides by w for us, so dividing these by their\n     own interpolated w in the fragment stage is the perspective-correct answer at every pixel. */\n  @location(0) now: vec4<f32>,\n  @location(1) was: vec4<f32>,\n}\n\n@vertex\nfn motionVert(@location(0) position: vec3<f32>) -> Varyings {\n  let world = draw.model * vec4<f32>(position, 1.0);\n  let wasWorld = draw.previousModel * vec4<f32>(position, 1.0);\n  var out: Varyings;\n  out.clip = frame.raster * world;\n  out.now = frame.viewProj * world;\n  out.was = frame.previousViewProj * wasWorld;\n  return out;\n}\n\n/* Normalised device coordinates to the uv the resolve measures in: v increases upward, as the\n   references' images do, and the accessor that reads this target is what flips the texture's rows. */\nfn motionUv(clip: vec4<f32>) -> vec2<f32> {\n  return clip.xy / clip.w * 0.5 + vec2<f32>(0.5);\n}\n\n@fragment\nfn motionFrag(in: Varyings) -> @location(0) vec4<f32> {\n  /*\n   * A surface behind last frame's eye has a w that is not positive, and there is no uv for it. The\n   * flag stays set: the disocclusion refuses a depth that is not positive, so the resolve drops the\n   * history rather than reading it from wherever a divide by a negative w would have pointed.\n   */\n  let offset = select(vec2<f32>(0.0), motionUv(in.was) - motionUv(in.now), in.was.w > 0.0);\n  return vec4<f32>(offset, in.was.w, 1.0);\n}\n";
+export declare const RECON_MOTION_WGSL = "\nstruct MotionFrame {\n  /* The scene's own clip transform, with the generated shaders' y negation already folded in. */\n  raster: mat4x4<f32>,\n  /* This frame's and last frame's view-projections, unjittered, in the matrices' own convention. */\n  viewProj: mat4x4<f32>,\n  previousViewProj: mat4x4<f32>,\n}\n\nstruct MotionDraw {\n  model: mat4x4<f32>,\n  previousModel: mat4x4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> frame: MotionFrame;\n@group(0) @binding(1) var<uniform> draw: MotionDraw;\n\nstruct Varyings {\n  @builtin(position) clip: vec4<f32>,\n  /* Clip positions rather than uv: an interpolator divides by w for us, so dividing these by their\n     own interpolated w in the fragment stage is the perspective-correct answer at every pixel. */\n  @location(0) now: vec4<f32>,\n  @location(1) was: vec4<f32>,\n}\n\n@vertex\nfn motionVert(@location(0) position: vec3<f32>) -> Varyings {\n  let world = draw.model * vec4<f32>(position, 1.0);\n  let wasWorld = draw.previousModel * vec4<f32>(position, 1.0);\n  var out: Varyings;\n  out.clip = frame.raster * world;\n  out.now = frame.viewProj * world;\n  out.was = frame.previousViewProj * wasWorld;\n  return out;\n}\n\n/* Normalised device coordinates to the uv the resolve measures in: v increases upward, as the\n   references' images do, and the accessor that reads this target is what flips the texture's rows. */\nfn motionUv(clip: vec4<f32>) -> vec2<f32> {\n  return clip.xy / clip.w * 0.5 + vec2<f32>(0.5);\n}\n\n/*\n * The skinned stage: the joints this frame and last frame, read from two palette textures of the\n * frame's ring. The same four weighted products in the same order as the scene's own skinning, so\n * the depth this stage produces is the depth the scene wrote.\n */\n@group(1) @binding(0) var palette: texture_2d<f32>;\n@group(1) @binding(1) var previousPalette: texture_2d<f32>;\n\nfn jointOf(source: texture_2d<f32>, index: i32) -> mat4x4<f32> {\n  let x = index * 4;\n  return mat4x4<f32>(\n    textureLoad(source, vec2<i32>(x, 0), 0),\n    textureLoad(source, vec2<i32>(x + 1, 0), 0),\n    textureLoad(source, vec2<i32>(x + 2, 0), 0),\n    textureLoad(source, vec2<i32>(x + 3, 0), 0));\n}\n\nfn skinOf(source: texture_2d<f32>, joints: vec4<f32>, weights: vec4<f32>) -> mat4x4<f32> {\n  return jointOf(source, i32(joints.x)) * weights.x\n       + jointOf(source, i32(joints.y)) * weights.y\n       + jointOf(source, i32(joints.z)) * weights.z\n       + jointOf(source, i32(joints.w)) * weights.w;\n}\n\n@vertex\nfn motionSkinnedVert(\n  @location(0) position: vec3<f32>,\n  @location(11) joints: vec4<f32>,\n  @location(12) weights: vec4<f32>,\n) -> Varyings {\n  let world = draw.model * (skinOf(palette, joints, weights) * vec4<f32>(position, 1.0));\n  let wasWorld =\n    draw.previousModel * (skinOf(previousPalette, joints, weights) * vec4<f32>(position, 1.0));\n  var out: Varyings;\n  out.clip = frame.raster * world;\n  out.now = frame.viewProj * world;\n  out.was = frame.previousViewProj * wasWorld;\n  return out;\n}\n\n/*\n * The rewritten stage: a mesh whose vertices were rewritten this frame reads last frame's rows from\n * a second buffer of the same stride, so each vertex carries both of its positions.\n */\n@vertex\nfn motionDynamicVert(\n  @location(0) position: vec3<f32>,\n  @location(1) previousPosition: vec3<f32>,\n) -> Varyings {\n  let world = draw.model * vec4<f32>(position, 1.0);\n  let wasWorld = draw.previousModel * vec4<f32>(previousPosition, 1.0);\n  var out: Varyings;\n  out.clip = frame.raster * world;\n  out.now = frame.viewProj * world;\n  out.was = frame.previousViewProj * wasWorld;\n  return out;\n}\n\n/*\n * The instanced stage: each instance's matrix this frame and last frame, read from the batch's\n * placement and the copy of last frame's it kept. Slot for slot, so an instance is paired with\n * itself; the per-draw matrices are not read.\n */\n@vertex\nfn motionInstancedVert(\n  @location(0) position: vec3<f32>,\n  @location(2) m0: vec4<f32>,\n  @location(3) m1: vec4<f32>,\n  @location(4) m2: vec4<f32>,\n  @location(5) m3: vec4<f32>,\n  @location(6) p0: vec4<f32>,\n  @location(7) p1: vec4<f32>,\n  @location(8) p2: vec4<f32>,\n  @location(9) p3: vec4<f32>,\n) -> Varyings {\n  let world = mat4x4<f32>(m0, m1, m2, m3) * vec4<f32>(position, 1.0);\n  let wasWorld = mat4x4<f32>(p0, p1, p2, p3) * vec4<f32>(position, 1.0);\n  var out: Varyings;\n  out.clip = frame.raster * world;\n  out.now = frame.viewProj * world;\n  out.was = frame.previousViewProj * wasWorld;\n  return out;\n}\n\n@fragment\nfn motionFrag(in: Varyings) -> @location(0) vec4<f32> {\n  /*\n   * A surface behind last frame's eye has a w that is not positive, and there is no uv for it. The\n   * flag stays set: the disocclusion refuses a depth that is not positive, so the resolve drops the\n   * history rather than reading it from wherever a divide by a negative w would have pointed.\n   */\n  let offset = select(vec2<f32>(0.0), motionUv(in.was) - motionUv(in.now), in.was.w > 0.0);\n  return vec4<f32>(offset, in.was.w, 1.0);\n}\n";