@driftengine/core 3.63.0 → 4.0.0

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

@@ -0,0 +1,127 @@
+/**
+ * Putting the GPU-driven pipeline's colour into the frame it was invited to draw in.
+ *
+ * **A contributed pass cannot write into the frame's attachment directly and should not want
+ * to.** `pass.ts` refuses a declared write-set for a reason it states at length; what a pass gets
+ * instead is a target of its own and a draw call at the point the caller put it. So the pipeline
+ * fills a storage texture in `prepare` and this puts it on the screen in `draw` — one triangle, no
+ * sampler, and `textureLoad` at the fragment's own pixel.
+ *
+ * **`textureLoad` rather than a sampler, because there is nothing to filter.** The target is the
+ * frame's own size and the mapping is one texel to one pixel; a sampler would add a filtering mode
+ * to choose and a half-pixel offset to get wrong, in exchange for nothing. It also means the
+ * texture needs no `filterable` sample type, which `rgba16float` has but which a future `r32float`
+ * would not.
+ *
+ * **It writes linear light.** The output transform is the composite's, for the reason
+ * `PassContext` gives: with a composite the resolve grades and a pass that also graded would apply
+ * the curve twice. A frame without one is refused in words rather than papered over — see the
+ * pass's `draw`.
+ */
+export const GPU_DRIVEN_BLIT_WGSL = `
+struct Varying {
+  @builtin(position) position: vec4<f32>,
+}
+
+@group(0) @binding(0) var source: texture_2d<f32>;
+
+@vertex
+fn vertexMain(@builtin(vertex_index) vertex: u32) -> Varying {
+  /* One triangle covering the frame rather than two: no shared edge, no diagonal seam, and the
+     third of the area outside the viewport costs nothing. */
+  var corners = array<vec2<f32>, 3>(
+    vec2<f32>(-1.0, -1.0),
+    vec2<f32>(3.0, -1.0),
+    vec2<f32>(-1.0, 3.0),
+  );
+  var out: Varying;
+  out.position = vec4<f32>(corners[vertex], 0.0, 1.0);
+  return out;
+}
+
+@fragment
+fn fragmentMain(in: Varying) -> @location(0) vec4<f32> {
+  /* The fragment's own pixel. Clamped rather than trusted: a frame larger than the pass's target
+     is a caller that did not resize, and reading out of bounds is a zero this would draw as a
+     black band nobody could place. */
+  let size = textureDimensions(source);
+  let at = min(vec2<u32>(in.position.xy), size - vec2<u32>(1u, 1u));
+  let texel = textureLoad(source, at, 0);
+  /*
+   * **Nothing was drawn here, so nothing is written — and that is a cost, not a correctness
+   * guard.** The target is cleared to zero and a zero laid over anything premultiplied is that
+   * thing, so the pixel would come out the same either way; this spares every pixel the pipeline
+   * did not cover a blend. Removing it left "depth-share-check.mjs" green on 2026-09-18, which is
+   * what says so. Alpha is the coverage: the shading writes one and a blended surface adds its own.
+   *
+   * **Returned as it is, premultiplied, and the pipeline blends it over.** Where the visibility
+   * buffer covered the pixel the coverage is one and over is a plain write. Where only a pane did,
+   * it is the pane's coverage, and the frame behind it — the sky — has to show through by the rest.
+   * This used to discard below a half and write the colour as opaque, which painted a heavy pane
+   * over black and dropped a light one altogether.
+   */
+  if (texel.a <= 0.0) { discard; }
+  return texel;
+}
+`;
+/**
+ * The same blit, handing the frame the pass's depth as well as its colour.
+ *
+ * **Two pipelines in one frame need one depth buffer.** The blit above presents colour and nothing
+ * else, which is right for a consumer whose whole scene is this pipeline — and wrong for one that
+ * draws its own geometry beside it, because then a forward-path mesh behind GPU-driven geometry has
+ * nothing to be hidden by. No ordering fixes that: drawn before the blit it is painted over, drawn
+ * after it floats in front of a hill.
+ *
+ * **The formats already agree.** The pass's depth texture and the frame's both take `DEPTH_FORMAT`
+ * and `DEPTH_COMPARE` from `depthConvention.ts`, so this is the same format and the same reversed
+ * convention and there is no conversion to get wrong. `gpuDrivenPass.ts` asserts that rather than
+ * trusting it, because a backend that ever differed would produce a depth test that is silently
+ * inverted instead of one that fails.
+ *
+ * **A pixel the pipeline did not cover is discarded before it writes**, exactly as above, so the
+ * sky keeps the depth the frame already had rather than being pushed to the near plane. A pixel
+ * only a pane covered writes the depth the pass cleared to, which is the frame's own clear — the
+ * pipeline compares "or equal" so that it passes over the sky, and what it writes there is the
+ * value already there.
+ */
+export const GPU_DRIVEN_BLIT_DEPTH_WGSL = /* wgsl */ `
+struct Varying {
+  @builtin(position) position: vec4<f32>,
+}
+
+struct Presented {
+  @location(0) colour: vec4<f32>,
+  @builtin(frag_depth) depth: f32,
+}
+
+@group(0) @binding(0) var source: texture_2d<f32>;
+@group(0) @binding(1) var sourceDepth: texture_depth_2d;
+
+@vertex
+fn vertexMain(@builtin(vertex_index) vertex: u32) -> Varying {
+  var corners = array<vec2<f32>, 3>(
+    vec2<f32>(-1.0, -1.0),
+    vec2<f32>(3.0, -1.0),
+    vec2<f32>(-1.0, 3.0),
+  );
+  var out: Varying;
+  out.position = vec4<f32>(corners[vertex], 0.0, 1.0);
+  return out;
+}
+
+@fragment
+fn fragmentMain(in: Varying) -> Presented {
+  let size = textureDimensions(source);
+  let at = min(vec2<u32>(in.position.xy), size - vec2<u32>(1u, 1u));
+  let texel = textureLoad(source, at, 0);
+  /* A cost here too: the depth the pass cleared to passes only where the frame holds that same
+     clear, so the write would change nothing. The colour blit above says how that was measured. */
+  if (texel.a <= 0.0) { discard; }
+  var out: Presented;
+  out.colour = texel;
+  /* The depth this pixel was rastered at, so the frame tests against the surface it can see. */
+  out.depth = textureLoad(sourceDepth, at, 0);
+  return out;
+}
+`;

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

@@ -0,0 +1,127 @@
+/**
+ * Rebuilding a pixel's surface from the triangle it recorded, on the device.
+ *
+ * **The same arithmetic as `gpudriven/shadeBins.ts`, term for term**, and
+ * `scripts/gpu-parity.mjs` runs both over generated triangles until they agree. That is the whole
+ * safety property of this file: a visibility buffer's interpolation is the only part of the
+ * shading that differs between the two pipelines, so it is the only part that can drift, and the
+ * check is on the part that can drift.
+ *
+ * **The lighting is not here and must not arrive here.** What this pass produces is a surface — a
+ * position, a normal, texture coordinates and their screen gradients — and the lit expression that
+ * consumes it is the forward path's own, wired in when the pipeline is assembled. A second copy of
+ * the lighting would drift from the first and the parity gate would be the only thing that
+ * noticed; the plan says so in those words and it is right.
+ *
+ * **Gradients are derived, not differenced.** A fragment shader gets `dpdx` and `dpdy` because it
+ * runs in quads of four; a compute invocation has no neighbours and no derivative at all. Without
+ * an analytic one a texture read picks a fixed level, which is blurry everywhere, or level zero,
+ * which sparkles — and neither reads as a missing derivative.
+ */
+/**
+ * The interpolation itself, with no bindings and no layout in it.
+ *
+ * **Its own string because two shaders do this and only one of them can be checked.** The
+ * reconstruction below is run against `shadeBins.ts` over generated triangles by
+ * `gpu-parity.mjs`; the pipeline's real shading pass reads different buffers and writes a colour,
+ * so nothing can compare it to a reference. Sharing the *text* is what makes the checked one
+ * speak for both — a second copy of the quotient rule would be the half nobody is watching, which
+ * is precisely the arrangement this wave keeps finding and refusing.
+ *
+ * Takes clip positions and pixel centres and answers weights and their two gradients. `valid` is
+ * false for a degenerate triangle or a perspective denominator at zero, which is a visibility
+ * identifier for a triangle the rasteriser never drew.
+ */
+export declare const SHADE_SURFACE_WGSL = "\nstruct Screen {\n  x: f32,\n  y: f32,\n  invW: f32,\n}\n\nstruct Weights {\n  /** The perspective-correct barycentric weights. */\n  c: vec3<f32>,\n  /** How each of them changes with screen x, and with screen y. */\n  gx: vec3<f32>,\n  gy: vec3<f32>,\n  valid: bool,\n}\n\nfn screenOf(clip: vec4<f32>, width: f32, height: f32) -> Screen {\n  let inv = 1.0 / clip.w;\n  var out: Screen;\n  out.x = (clip.x * inv * 0.5 + 0.5) * width;\n  out.y = (clip.y * inv * 0.5 + 0.5) * height;\n  out.invW = inv;\n  return out;\n}\n\nfn surfaceWeights(s0: Screen, s1: Screen, s2: Screen, px: f32, py: f32) -> Weights {\n  var out: Weights;\n  out.valid = false;\n\n  let area = (s1.x - s0.x) * (s2.y - s0.y) - (s2.x - s0.x) * (s1.y - s0.y);\n  if (abs(area) < 1e-12) { return out; }\n  let inverse = 1.0 / area;\n\n  /* Screen-space weights. A point outside the triangle gets a negative one rather than a clamp:\n     clamping shades a pixel beyond an edge as though it were on the triangle. */\n  let l1 = ((px - s0.x) * (s2.y - s0.y) - (s2.x - s0.x) * (py - s0.y)) * inverse;\n  let l2 = ((s1.x - s0.x) * (py - s0.y) - (px - s0.x) * (s1.y - s0.y)) * inverse;\n  let l0 = 1.0 - l1 - l2;\n\n  let n0 = l0 * s0.invW;\n  let n1 = l1 * s1.invW;\n  let n2 = l2 * s2.invW;\n  let sum = n0 + n1 + n2;\n  if (abs(sum) < 1e-20) { return out; }\n  let invSum = 1.0 / sum;\n  out.c = vec3<f32>(n0 * invSum, n1 * invSum, n2 * invSum);\n\n  /* The screen weights' gradients, constant over the triangle. */\n  let d1dx = (s2.y - s0.y) * inverse;\n  let d1dy = (s0.x - s2.x) * inverse;\n  let d2dx = (s0.y - s1.y) * inverse;\n  let d2dy = (s1.x - s0.x) * inverse;\n  let d0dx = -d1dx - d2dx;\n  let d0dy = -d1dy - d2dy;\n\n  let dSumDx = d0dx * s0.invW + d1dx * s1.invW + d2dx * s2.invW;\n  let dSumDy = d0dy * s0.invW + d1dy * s1.invW + d2dy * s2.invW;\n\n  /* Quotient rule, per weight, with the shared denominator factored out. */\n  out.gx = vec3<f32>(\n    (d0dx * s0.invW - n0 * invSum * dSumDx) * invSum,\n    (d1dx * s1.invW - n1 * invSum * dSumDx) * invSum,\n    (d2dx * s2.invW - n2 * invSum * dSumDx) * invSum,\n  );\n  out.gy = vec3<f32>(\n    (d0dy * s0.invW - n0 * invSum * dSumDy) * invSum,\n    (d1dy * s1.invW - n1 * invSum * dSumDy) * invSum,\n    (d2dy * s2.invW - n2 * invSum * dSumDy) * invSum,\n  );\n  out.valid = true;\n  return out;\n}\n\n/* surfaceFrame.ts surfaceLod: the longer screen-axis UV step, in texels, as a power of two. */\nfn surfaceLod(gradX: vec2<f32>, gradY: vec2<f32>, size: f32) -> f32 {\n  let footprint = max(length(gradX), length(gradY)) * size;\n  return max(log2(max(footprint, 1e-30)), 0.0);\n}\n\nstruct TangentFrame {\n  t: vec3<f32>,\n  b: vec3<f32>,\n}\n\n/* surfaceFrame.ts derivedTangentFrame, which is tangentFrame.ts's derived branch term for term. */\nfn derivedTangentFrame(\n  n: vec3<f32>,\n  dp1: vec3<f32>,\n  dp2: vec3<f32>,\n  duv1: vec2<f32>,\n  duv2: vec2<f32>,\n) -> TangentFrame {\n  let dp2perp = cross(dp2, n);\n  let dp1perp = cross(n, dp1);\n  let dt = dp2perp * duv1.x + dp1perp * duv2.x;\n  let db = dp2perp * duv1.y + dp1perp * duv2.y;\n  let det = duv1.x * duv2.y - duv2.x * duv1.y;\n  let handed = select(1.0, -1.0, det < 0.0);\n  let scale = inverseSqrt(max(max(dot(dt, dt), dot(db, db)), 1e-12)) * handed;\n  var frame: TangentFrame;\n  frame.t = dt * scale;\n  frame.b = db * scale;\n  return frame;\n}\n";
+/**
+ * One invocation a pixel of one material's bin.
+ *
+ * `settings` is the bin's offset, its length, the screen width and the screen height. A dispatch
+ * is issued per material from the blocks `materialBin.wgsl.ts` wrote, so the bin this reads is
+ * whichever one the caller bound — the shader does not choose.
+ *
+ * The outputs here are the reconstruction rather than a colour, because that is what can be
+ * compared against a reference. In the assembled pipeline the same values feed the lit expression
+ * and the colour is what lands.
+ */
+export declare const SHADE_RECONSTRUCT_WGSL = "\nstruct Screen {\n  x: f32,\n  y: f32,\n  invW: f32,\n}\n\nstruct Weights {\n  /** The perspective-correct barycentric weights. */\n  c: vec3<f32>,\n  /** How each of them changes with screen x, and with screen y. */\n  gx: vec3<f32>,\n  gy: vec3<f32>,\n  valid: bool,\n}\n\nfn screenOf(clip: vec4<f32>, width: f32, height: f32) -> Screen {\n  let inv = 1.0 / clip.w;\n  var out: Screen;\n  out.x = (clip.x * inv * 0.5 + 0.5) * width;\n  out.y = (clip.y * inv * 0.5 + 0.5) * height;\n  out.invW = inv;\n  return out;\n}\n\nfn surfaceWeights(s0: Screen, s1: Screen, s2: Screen, px: f32, py: f32) -> Weights {\n  var out: Weights;\n  out.valid = false;\n\n  let area = (s1.x - s0.x) * (s2.y - s0.y) - (s2.x - s0.x) * (s1.y - s0.y);\n  if (abs(area) < 1e-12) { return out; }\n  let inverse = 1.0 / area;\n\n  /* Screen-space weights. A point outside the triangle gets a negative one rather than a clamp:\n     clamping shades a pixel beyond an edge as though it were on the triangle. */\n  let l1 = ((px - s0.x) * (s2.y - s0.y) - (s2.x - s0.x) * (py - s0.y)) * inverse;\n  let l2 = ((s1.x - s0.x) * (py - s0.y) - (px - s0.x) * (s1.y - s0.y)) * inverse;\n  let l0 = 1.0 - l1 - l2;\n\n  let n0 = l0 * s0.invW;\n  let n1 = l1 * s1.invW;\n  let n2 = l2 * s2.invW;\n  let sum = n0 + n1 + n2;\n  if (abs(sum) < 1e-20) { return out; }\n  let invSum = 1.0 / sum;\n  out.c = vec3<f32>(n0 * invSum, n1 * invSum, n2 * invSum);\n\n  /* The screen weights' gradients, constant over the triangle. */\n  let d1dx = (s2.y - s0.y) * inverse;\n  let d1dy = (s0.x - s2.x) * inverse;\n  let d2dx = (s0.y - s1.y) * inverse;\n  let d2dy = (s1.x - s0.x) * inverse;\n  let d0dx = -d1dx - d2dx;\n  let d0dy = -d1dy - d2dy;\n\n  let dSumDx = d0dx * s0.invW + d1dx * s1.invW + d2dx * s2.invW;\n  let dSumDy = d0dy * s0.invW + d1dy * s1.invW + d2dy * s2.invW;\n\n  /* Quotient rule, per weight, with the shared denominator factored out. */\n  out.gx = vec3<f32>(\n    (d0dx * s0.invW - n0 * invSum * dSumDx) * invSum,\n    (d1dx * s1.invW - n1 * invSum * dSumDx) * invSum,\n    (d2dx * s2.invW - n2 * invSum * dSumDx) * invSum,\n  );\n  out.gy = vec3<f32>(\n    (d0dy * s0.invW - n0 * invSum * dSumDy) * invSum,\n    (d1dy * s1.invW - n1 * invSum * dSumDy) * invSum,\n    (d2dy * s2.invW - n2 * invSum * dSumDy) * invSum,\n  );\n  out.valid = true;\n  return out;\n}\n\n/* surfaceFrame.ts surfaceLod: the longer screen-axis UV step, in texels, as a power of two. */\nfn surfaceLod(gradX: vec2<f32>, gradY: vec2<f32>, size: f32) -> f32 {\n  let footprint = max(length(gradX), length(gradY)) * size;\n  return max(log2(max(footprint, 1e-30)), 0.0);\n}\n\nstruct TangentFrame {\n  t: vec3<f32>,\n  b: vec3<f32>,\n}\n\n/* surfaceFrame.ts derivedTangentFrame, which is tangentFrame.ts's derived branch term for term. */\nfn derivedTangentFrame(\n  n: vec3<f32>,\n  dp1: vec3<f32>,\n  dp2: vec3<f32>,\n  duv1: vec2<f32>,\n  duv2: vec2<f32>,\n) -> TangentFrame {\n  let dp2perp = cross(dp2, n);\n  let dp1perp = cross(n, dp1);\n  let dt = dp2perp * duv1.x + dp1perp * duv2.x;\n  let db = dp2perp * duv1.y + dp1perp * duv2.y;\n  let det = duv1.x * duv2.y - duv2.x * duv1.y;\n  let handed = select(1.0, -1.0, det < 0.0);\n  let scale = inverseSqrt(max(max(dot(dt, dt), dot(db, db)), 1e-12)) * handed;\n  var frame: TangentFrame;\n  frame.t = dt * scale;\n  frame.b = db * scale;\n  return frame;\n}\n\nconst VIS_TRIANGLE_BITS: u32 = 7u;\nconst VIS_EMPTY: u32 = 0xffffffffu;\n\n/** binOffset, binCount, width, height. */\n@group(0) @binding(0) var<storage, read> settings: array<u32, 4>;\n@group(0) @binding(1) var<storage, read> binPixels: array<u32>;\n@group(0) @binding(2) var<storage, read> visibility: array<u32>;\n/** Four words a cluster: index offset, index count, cluster identifier, mesh. */\n@group(0) @binding(3) var<storage, read> clusterMeta: array<u32>;\n@group(0) @binding(4) var<storage, read> indices: array<u32>;\n/** Four floats a vertex: clip x, clip y, clip w, and one attribute to interpolate. */\n@group(0) @binding(5) var<storage, read> vertices: array<f32>;\n/** Six floats a pixel: the interpolated attribute, its two gradients, and the three weights. */\n@group(0) @binding(6) var<storage, read_write> surface: array<f32>;\n\nfn clipOf(vertex: u32) -> vec4<f32> {\n  let at = vertex * 4u;\n  return vec4<f32>(vertices[at], vertices[at + 1u], 0.0, vertices[at + 2u]);\n}\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) id: vec3<u32>) {\n  /* Past the end of the bin, which is the ordinary case: a bin is not a multiple of the group\n     size, and the spare lanes must do nothing rather than shade the last pixel again. */\n  if (id.x >= settings[1]) { return; }\n  let pixel = binPixels[settings[0] + id.x];\n  let packed = visibility[pixel];\n  if (packed == VIS_EMPTY) { return; }\n\n  let cluster = packed >> VIS_TRIANGLE_BITS;\n  let triangle = packed & 127u;\n  let metaAt = cluster * 4u;\n  let indexOffset = clusterMeta[metaAt];\n\n  let i0 = indices[indexOffset + triangle * 3u];\n  let i1 = indices[indexOffset + triangle * 3u + 1u];\n  let i2 = indices[indexOffset + triangle * 3u + 2u];\n\n  let width = f32(settings[2]);\n  let height = f32(settings[3]);\n  let s0 = screenOf(clipOf(i0), width, height);\n  let s1 = screenOf(clipOf(i1), width, height);\n  let s2 = screenOf(clipOf(i2), width, height);\n\n  /* Pixel centres, which is where a rasteriser decided this pixel was covered. */\n  let px = f32(pixel % settings[2]) + 0.5;\n  let py = f32(pixel / settings[2]) + 0.5;\n\n  let w = surfaceWeights(s0, s1, s2, px, py);\n  if (!w.valid) { return; }\n\n  let a = vec3<f32>(\n    vertices[i0 * 4u + 3u],\n    vertices[i1 * 4u + 3u],\n    vertices[i2 * 4u + 3u],\n  );\n\n  let out = id.x * 6u;\n  surface[out] = dot(a, w.c);\n  surface[out + 1u] = dot(a, w.gx);\n  surface[out + 2u] = dot(a, w.gy);\n  surface[out + 3u] = w.c.x;\n  surface[out + 4u] = w.c.y;\n  surface[out + 5u] = w.c.z;\n}\n";
+/**
+ * One dispatch a material: every pixel in that material's bin, lit and written to the frame.
+ *
+ * **This is the assembled half, and it is the one nothing can compare against a reference.** The
+ * interpolation it rests on is `SHADE_SURFACE_WGSL` above, which *is* compared — that sharing is
+ * the point of the split, because the quotient rule is what drifts and a second copy of it would
+ * be the copy nobody watches.
+ *
+ * **Which material a dispatch is shading arrives in a uniform with a per-material bind group**, not
+ * in the shader. There is no builtin for "which dispatch am I", and a shader per material would be
+ * a pipeline per material — so one pipeline is bound once and group one moves per dispatch. The
+ * bin's own offset and length are read from the buffers `materialBin.wgsl.ts` wrote rather than
+ * passed in, so there is one statement of where a bin is.
+ *
+ * **Eight storage buffers is the budget and this pass spends all of it.**
+ * `maxStorageBuffersPerShaderStage` is 8 by default; this adapter offers 16 and most do, and a
+ * pipeline that asked for the higher limit would refuse to create a device on the ones that do
+ * not. So the vertex attributes are interleaved into one buffer rather than three, and the frame
+ * block and the material table are uniforms. Found at pipeline creation with twelve.
+ *
+ * **What the lighting here is, and what it is not.** Vertex colour times the material's tint, one
+ * directional term with its highlight and its shadow, the same hemispheric ambient the forward path
+ * uses — `mix(ground, sky, n.y * 0.5 + 0.5)` — and the material's emissive. It is not the forward
+ * path's standard material: no image-based term and no texture. Those belong to a pipeline that
+ * draws the published scenes, and this one draws drafts. **Stating the gap is the point**;
+ * discovering it from a capture is what this repository keeps refusing.
+ *
+ * **The pixel centre is the flipped row.** WebGPU's framebuffer origin is the top-left, so row zero
+ * is where clip y is +1, and `screenOf` maps clip y of +1 to `height`. The flip belongs to the
+ * pixel rather than to the shared function, which is checked against a reference and must not
+ * learn about a framebuffer; flipping all four points of a barycentric evaluation leaves the
+ * weights unchanged, which is why this is the whole of it.
+ *
+ * **The normal is transformed by the upper three-by-three and renormalised**, which is right for
+ * the rigid transforms with uniform scale the draft scenes use and wrong for a non-uniform one —
+ * that wants the inverse transpose. A scene that needs it will find this comment rather than a
+ * lighting error nobody can place.
+ */
+/**
+ * The lit expression, as text, with no bindings in it.
+ *
+ * **Its own string for the reason the reconstruction above has one, arrived at the same way.** The
+ * shading pass writes a colour into a storage texture, so nothing could compare it to a reference —
+ * and for as long as the expression was four lines, the shading pass's header argued that nothing
+ * needed to. That argument stops the moment the expression grows a term. `gpudriven/lit.ts` is the
+ * twin now, `SHADE_LIGHTING_PARITY_WGSL` below is an entry point that does nothing but call this,
+ * and `scripts/gpu-parity.mjs` runs both over generated surfaces.
+ *
+ * Every term matches `flat/main.ts` at the one configuration this pipeline supports — metalness
+ * zero, which collapses the Fresnel blend on the highlight to the surface's own reflectance.
+ */
+export declare const SHADE_LIGHTING_WGSL = "\n/* The normalised GGX distribution, transcribed from flat/lobes.ts. See lit.ts about its peak. */\n/*\n * **Two floors, and only one of them can be seen in the output.** The denominator's is what keeps\n * a near-mirror's peak finite, and deleting it is worth 256 times the highlight at roughness 0.05 \u2014\n * gpu-parity.mjs catches that, now that a fifth of its corpus sits on the peak. The floor on a\n * cannot be caught, because the denominator's already prevents the division by zero it guards\n * against: at roughness zero the whole term is a ten-thousandth with it and zero without, and both\n * round to nothing beside a lit surface. It is kept because it is what flat/lobes.ts has, and two\n * spellings of one lobe differing by a guard is the drift this pair exists to prevent.\n */\nfn specularLobe(ndh: f32, roughness: f32) -> f32 {\n  let a = max(roughness * roughness, 0.01);\n  let a2 = a * a;\n  let d = ndh * ndh * (a2 - 1.0) + 1.0;\n  return (a2 * a2) / max(d * d, 1e-8);\n}\n\n/* A dielectric's normal-incidence reflectance, which every material in this pipeline is. */\nconst DIELECTRIC_F0: f32 = 0.04;\n\n/*\n * The split sum's second half, as Karis's analytic fit: dfg.x scales f0 and dfg.y adds on top.\n * gpudriven/ibl.ts is the twin and carries what the tabulated integral would cost instead.\n */\nfn envBrdfApprox(ndv: f32, roughness: f32) -> vec2<f32> {\n  let c0 = vec4<f32>(-1.0, -0.0275, -0.572, 0.022);\n  let c1 = vec4<f32>(1.0, 0.0425, 1.04, -0.04);\n  let r = roughness * c0 + c1;\n  let a004 = min(r.x * r.x, exp2(-9.28 * ndv)) * r.x + r.y;\n  return vec2<f32>(-1.04, 1.04) * a004 + r.zw;\n}\n\n/*\n * The same with the multiply-scattered light put back. At f0 of one this returns exactly 1.0 at\n * every roughness, which is the invariant ibl.test.ts asserts across the range: roughness\n * scatters light and does not absorb it, and the bare split sum claims otherwise by up to 44%.\n */\nfn envSpecularEnergy(f0: f32, dfg: vec2<f32>) -> f32 {\n  let single = f0 * dfg.x + dfg.y;\n  let energy = dfg.x + dfg.y;\n  let missing = 1.0 - energy;\n  let average = f0 + (1.0 - f0) / 21.0;\n  let multi = single * average / (1.0 - missing * average);\n  return single + multi * missing;\n}\n\n/*\n * How much of what the surface sees in the mirror direction reaches the frame.\n *\n * Two expressions and a selector that is exactly 0 or exactly 1: the split sum is the correct\n * share of a prefiltered environment and asserts an integral that was never performed over\n * anything else. See ibl.ts for what ignoring that costs on the other pipeline.\n */\nfn surfaceF0(metalness: f32) -> f32 {\n  return mix(DIELECTRIC_F0, 1.0, metalness);\n}\n\nfn environmentWeight(\n  ndv: f32,\n  roughness: f32,\n  reflectivity: f32,\n  prefiltered: f32,\n  metalness: f32,\n) -> f32 {\n  let f0 = surfaceF0(metalness);\n  let facing = 1.0 - ndv;\n  let fresnel = mix(f0, 1.0, facing * facing * facing * facing * facing);\n  /*\n   * max(reflectivity * (1 - roughness), metal), and both halves are repairs flat/main.ts records:\n   * a metal reflects whether or not the pass asked for reflections, and the one-minus-roughness\n   * thinning belongs to the dielectric alone. See ibl.ts.\n   */\n  let amount = max(reflectivity * (1.0 - roughness), metalness);\n  let sweep = clamp(fresnel * amount, 0.0, 1.0);\n  let dfg = envBrdfApprox(ndv, roughness);\n  let integrated = clamp(envSpecularEnergy(f0, dfg) * max(reflectivity, metalness), 0.0, 1.0);\n  return mix(sweep, integrated, prefiltered);\n}\n\nstruct LitSurface {\n  albedo: vec3<f32>,\n  normal: vec3<f32>,\n  toEye: vec3<f32>,\n  roughness: f32,\n  specular: f32,\n  emissive: f32,\n  /*\n   * What the glow is coloured by: the albedo times an emissive map, flat/main.ts's\n   * emissiveTint * emissiveMapped. The albedo itself where the material binds no map. See lit.ts.\n   */\n  emissiveColour: vec3<f32>,\n  /* How much of the sun reaches here: 0 in full shadow, 1 in full light. See lit.ts. */\n  shade: f32,\n  reflectivity: f32,\n  /* 0 is a dielectric and 1 is a metal. One number a material here, an ORM texel there. */\n  metalness: f32,\n  /* A crevice's share of everything below, as flat/main.ts applies ormOcclusion. See lit.ts. */\n  occlusion: f32,\n}\n\nstruct LitEnvironment {\n  lightDir: vec3<f32>,\n  lightColour: vec3<f32>,\n  sky: vec3<f32>,\n  ground: vec3<f32>,\n  irradiance: vec3<f32>,\n  radiance: vec3<f32>,\n  irradianceAmount: f32,\n  /* How much of the mirror-direction gradient the radiance replaces. Zero keeps the gradient. */\n  radianceAmount: f32,\n  prefiltered: f32,\n  /* The frame's emissive gain times its night factor, which scales every glow. See lit.ts. */\n  emission: f32,\n}\n\nfn litColour(surface: LitSurface, env: LitEnvironment) -> vec3<f32> {\n  let n = surface.normal;\n  let albedo = surface.albedo;\n  let lightColour = env.lightColour;\n  let roughness = surface.roughness;\n  let shade = surface.shade;\n  let ndl = max(dot(n, env.lightDir), 0.0);\n  /*\n   * The forward path's own hemispheric term \u2014 flat/main.ts, mix(ground, sky, n.y * 0.5 + 0.5) \u2014\n   * replaced by the room's irradiance where a caller supplies one rather than lifted toward it.\n   */\n  let hemispheric = mix(env.ground, env.sky, n.y * 0.5 + 0.5);\n  let ambient = mix(hemispheric, env.irradiance, env.irradianceAmount);\n\n  /*\n   * The half vector between the light and the eye, and the highlight at its peak. Computed whether\n   * or not the surface is shiny and multiplied by zero where it is not: a branch on a value read\n   * from the material table is not provably uniform control flow, which is the rule this pass and\n   * the forward one both keep.\n   */\n  let halfway = env.lightDir + surface.toEye;\n  let length2 = dot(halfway, halfway);\n  var ndh = 0.0;\n  if (length2 > 0.0) {\n    ndh = max(dot(n, halfway * inverseSqrt(length2)), 0.0);\n  }\n  let lobe = specularLobe(ndh, roughness);\n  let metal = surface.metalness;\n  /*\n   * A metal's highlight takes its own colour and goes white at the edge; a dielectric's takes the\n   * light's and does neither. mix(specular, albedo, 0) is specular exactly, and the Schlick term is\n   * scaled by metalness, so at metalness 0 both lines are the expression that shipped before them.\n   */\n  let specColour = mix(vec3<f32>(surface.specular), albedo, metal);\n  let voh = select(0.0, max(dot(surface.toEye, halfway * inverseSqrt(length2)), 0.0), length2 > 0.0);\n  let facing = 1.0 - voh;\n  let sunSpec = mix(specColour, vec3<f32>(1.0), facing * facing * facing * facing * facing * metal);\n  let highlight = lightColour * lobe * sunSpec * shade;\n\n  /*\n   * Shade multiplies the two direct terms and not the ambient, which is where flat/main.ts puts\n   * its own sunShade and what its comment says the wider version costs. A metal keeps its ambient\n   * and loses its direct diffuse; the honest two terms cancel into this one.\n   */\n  let base = albedo * (ambient + lightColour * ndl * shade * (1.0 - metal)) + highlight * (1.0 - metal);\n  /*\n   * **The dielectric's highlight goes underneath the blend and the metal's goes on top**, which is\n   * flat/main.ts's two lines with the mix between them. Underneath, the blend dims it by the\n   * surface's own reflectance \u2014 taking it out puts a lobe that was correctly dimmed back at full\n   * strength, which on a near-black glass lens carrying specular 1 is a white blob where there was\n   * none. On top, it survives a weight of one, which is what a metal always has.\n   */\n  let nv = dot(n, surface.toEye);\n  let ndv = max(nv, 0.0);\n  /*\n   * What the surface sees along the mirror direction, and with no probe it is the same two-colour\n   * gradient the ambient comes from \u2014 which is what flat/main.ts reflects where a scene has no\n   * environment. Unclamped nv, because reflect takes the facing term as it is: clamping folds the\n   * direction back on a silhouette and reflects the sky where the ground belongs.\n   */\n  let mirrored = 2.0 * nv * n - surface.toEye;\n  let gradient = mix(env.ground, env.sky, mirrored.y * 0.5 + 0.5);\n  let seen = mix(gradient, env.radiance, env.radianceAmount);\n  let weight = environmentWeight(ndv, roughness, surface.reflectivity, env.prefiltered, metal);\n  /* A metal reflects the room through itself; mix(1, albedo, 0) is exactly 1 for a dielectric. */\n  let reflected = seen * mix(vec3<f32>(1.0), albedo, metal);\n  /* Scaled by the frame and dimmed by a share of the sun's shadow, as flat/main.ts's glow is. */\n  let glow = surface.emissive * env.emission\n    * mix(1.0, surface.shade, 0.55);\n  return (mix(base, reflected, weight) + highlight * metal + surface.emissiveColour * glow)\n    * surface.occlusion;\n}\n";
+export declare const SHADE_MATERIAL_WGSL: string;
+/**
+ * An entry point that does nothing but light a surface, so `gpu-parity.mjs` can compare the
+ * expression above with `gpudriven/lit.ts` directly rather than through a shading pass that writes
+ * to a texture and reads eleven buffers.
+ *
+ * `LIT_SURFACE_FLOATS` a surface: albedo, normal, the direction to the eye, then roughness,
+ * specular, emissive, shade, reflectivity, metalness, occlusion and the emitted colour; and
+ * `LIT_ENVIRONMENT_FLOATS` a room. The prose said fourteen and twenty for two waves after both had
+ * grown, which is why it names the constants now rather than counting them.
+ */
+/**
+ * Floats a surface of the lighting check. Matches `LitSurface`: occlusion at fifteen, then the
+ * emitted colour, which a surface with no emissive map sets to its albedo.
+ */
+export declare const LIT_SURFACE_FLOATS = 19;
+/**
+ * Floats an environment of the lighting check. Matches `LitEnvironment`.
+ *
+ * **One block a surface rather than one for the corpus**, which it was until the image-based term
+ * arrived: the room, the chain and the two selectors are per-pixel quantities in the shading pass,
+ * and a check that held them constant would run the split sum at exactly one configuration.
+ */
+export declare const LIT_ENVIRONMENT_FLOATS = 22;
+export declare const SHADE_LIGHTING_PARITY_WGSL = "\n@group(0) @binding(0) var<storage, read> params: array<f32>;\n@group(0) @binding(1) var<storage, read> environment: array<f32>;\n@group(0) @binding(2) var<storage, read> surfaces: array<f32>;\n@group(0) @binding(3) var<storage, read_write> colours: array<f32>;\n\n\n/* The normalised GGX distribution, transcribed from flat/lobes.ts. See lit.ts about its peak. */\n/*\n * **Two floors, and only one of them can be seen in the output.** The denominator's is what keeps\n * a near-mirror's peak finite, and deleting it is worth 256 times the highlight at roughness 0.05 \u2014\n * gpu-parity.mjs catches that, now that a fifth of its corpus sits on the peak. The floor on a\n * cannot be caught, because the denominator's already prevents the division by zero it guards\n * against: at roughness zero the whole term is a ten-thousandth with it and zero without, and both\n * round to nothing beside a lit surface. It is kept because it is what flat/lobes.ts has, and two\n * spellings of one lobe differing by a guard is the drift this pair exists to prevent.\n */\nfn specularLobe(ndh: f32, roughness: f32) -> f32 {\n  let a = max(roughness * roughness, 0.01);\n  let a2 = a * a;\n  let d = ndh * ndh * (a2 - 1.0) + 1.0;\n  return (a2 * a2) / max(d * d, 1e-8);\n}\n\n/* A dielectric's normal-incidence reflectance, which every material in this pipeline is. */\nconst DIELECTRIC_F0: f32 = 0.04;\n\n/*\n * The split sum's second half, as Karis's analytic fit: dfg.x scales f0 and dfg.y adds on top.\n * gpudriven/ibl.ts is the twin and carries what the tabulated integral would cost instead.\n */\nfn envBrdfApprox(ndv: f32, roughness: f32) -> vec2<f32> {\n  let c0 = vec4<f32>(-1.0, -0.0275, -0.572, 0.022);\n  let c1 = vec4<f32>(1.0, 0.0425, 1.04, -0.04);\n  let r = roughness * c0 + c1;\n  let a004 = min(r.x * r.x, exp2(-9.28 * ndv)) * r.x + r.y;\n  return vec2<f32>(-1.04, 1.04) * a004 + r.zw;\n}\n\n/*\n * The same with the multiply-scattered light put back. At f0 of one this returns exactly 1.0 at\n * every roughness, which is the invariant ibl.test.ts asserts across the range: roughness\n * scatters light and does not absorb it, and the bare split sum claims otherwise by up to 44%.\n */\nfn envSpecularEnergy(f0: f32, dfg: vec2<f32>) -> f32 {\n  let single = f0 * dfg.x + dfg.y;\n  let energy = dfg.x + dfg.y;\n  let missing = 1.0 - energy;\n  let average = f0 + (1.0 - f0) / 21.0;\n  let multi = single * average / (1.0 - missing * average);\n  return single + multi * missing;\n}\n\n/*\n * How much of what the surface sees in the mirror direction reaches the frame.\n *\n * Two expressions and a selector that is exactly 0 or exactly 1: the split sum is the correct\n * share of a prefiltered environment and asserts an integral that was never performed over\n * anything else. See ibl.ts for what ignoring that costs on the other pipeline.\n */\nfn surfaceF0(metalness: f32) -> f32 {\n  return mix(DIELECTRIC_F0, 1.0, metalness);\n}\n\nfn environmentWeight(\n  ndv: f32,\n  roughness: f32,\n  reflectivity: f32,\n  prefiltered: f32,\n  metalness: f32,\n) -> f32 {\n  let f0 = surfaceF0(metalness);\n  let facing = 1.0 - ndv;\n  let fresnel = mix(f0, 1.0, facing * facing * facing * facing * facing);\n  /*\n   * max(reflectivity * (1 - roughness), metal), and both halves are repairs flat/main.ts records:\n   * a metal reflects whether or not the pass asked for reflections, and the one-minus-roughness\n   * thinning belongs to the dielectric alone. See ibl.ts.\n   */\n  let amount = max(reflectivity * (1.0 - roughness), metalness);\n  let sweep = clamp(fresnel * amount, 0.0, 1.0);\n  let dfg = envBrdfApprox(ndv, roughness);\n  let integrated = clamp(envSpecularEnergy(f0, dfg) * max(reflectivity, metalness), 0.0, 1.0);\n  return mix(sweep, integrated, prefiltered);\n}\n\nstruct LitSurface {\n  albedo: vec3<f32>,\n  normal: vec3<f32>,\n  toEye: vec3<f32>,\n  roughness: f32,\n  specular: f32,\n  emissive: f32,\n  /*\n   * What the glow is coloured by: the albedo times an emissive map, flat/main.ts's\n   * emissiveTint * emissiveMapped. The albedo itself where the material binds no map. See lit.ts.\n   */\n  emissiveColour: vec3<f32>,\n  /* How much of the sun reaches here: 0 in full shadow, 1 in full light. See lit.ts. */\n  shade: f32,\n  reflectivity: f32,\n  /* 0 is a dielectric and 1 is a metal. One number a material here, an ORM texel there. */\n  metalness: f32,\n  /* A crevice's share of everything below, as flat/main.ts applies ormOcclusion. See lit.ts. */\n  occlusion: f32,\n}\n\nstruct LitEnvironment {\n  lightDir: vec3<f32>,\n  lightColour: vec3<f32>,\n  sky: vec3<f32>,\n  ground: vec3<f32>,\n  irradiance: vec3<f32>,\n  radiance: vec3<f32>,\n  irradianceAmount: f32,\n  /* How much of the mirror-direction gradient the radiance replaces. Zero keeps the gradient. */\n  radianceAmount: f32,\n  prefiltered: f32,\n  /* The frame's emissive gain times its night factor, which scales every glow. See lit.ts. */\n  emission: f32,\n}\n\nfn litColour(surface: LitSurface, env: LitEnvironment) -> vec3<f32> {\n  let n = surface.normal;\n  let albedo = surface.albedo;\n  let lightColour = env.lightColour;\n  let roughness = surface.roughness;\n  let shade = surface.shade;\n  let ndl = max(dot(n, env.lightDir), 0.0);\n  /*\n   * The forward path's own hemispheric term \u2014 flat/main.ts, mix(ground, sky, n.y * 0.5 + 0.5) \u2014\n   * replaced by the room's irradiance where a caller supplies one rather than lifted toward it.\n   */\n  let hemispheric = mix(env.ground, env.sky, n.y * 0.5 + 0.5);\n  let ambient = mix(hemispheric, env.irradiance, env.irradianceAmount);\n\n  /*\n   * The half vector between the light and the eye, and the highlight at its peak. Computed whether\n   * or not the surface is shiny and multiplied by zero where it is not: a branch on a value read\n   * from the material table is not provably uniform control flow, which is the rule this pass and\n   * the forward one both keep.\n   */\n  let halfway = env.lightDir + surface.toEye;\n  let length2 = dot(halfway, halfway);\n  var ndh = 0.0;\n  if (length2 > 0.0) {\n    ndh = max(dot(n, halfway * inverseSqrt(length2)), 0.0);\n  }\n  let lobe = specularLobe(ndh, roughness);\n  let metal = surface.metalness;\n  /*\n   * A metal's highlight takes its own colour and goes white at the edge; a dielectric's takes the\n   * light's and does neither. mix(specular, albedo, 0) is specular exactly, and the Schlick term is\n   * scaled by metalness, so at metalness 0 both lines are the expression that shipped before them.\n   */\n  let specColour = mix(vec3<f32>(surface.specular), albedo, metal);\n  let voh = select(0.0, max(dot(surface.toEye, halfway * inverseSqrt(length2)), 0.0), length2 > 0.0);\n  let facing = 1.0 - voh;\n  let sunSpec = mix(specColour, vec3<f32>(1.0), facing * facing * facing * facing * facing * metal);\n  let highlight = lightColour * lobe * sunSpec * shade;\n\n  /*\n   * Shade multiplies the two direct terms and not the ambient, which is where flat/main.ts puts\n   * its own sunShade and what its comment says the wider version costs. A metal keeps its ambient\n   * and loses its direct diffuse; the honest two terms cancel into this one.\n   */\n  let base = albedo * (ambient + lightColour * ndl * shade * (1.0 - metal)) + highlight * (1.0 - metal);\n  /*\n   * **The dielectric's highlight goes underneath the blend and the metal's goes on top**, which is\n   * flat/main.ts's two lines with the mix between them. Underneath, the blend dims it by the\n   * surface's own reflectance \u2014 taking it out puts a lobe that was correctly dimmed back at full\n   * strength, which on a near-black glass lens carrying specular 1 is a white blob where there was\n   * none. On top, it survives a weight of one, which is what a metal always has.\n   */\n  let nv = dot(n, surface.toEye);\n  let ndv = max(nv, 0.0);\n  /*\n   * What the surface sees along the mirror direction, and with no probe it is the same two-colour\n   * gradient the ambient comes from \u2014 which is what flat/main.ts reflects where a scene has no\n   * environment. Unclamped nv, because reflect takes the facing term as it is: clamping folds the\n   * direction back on a silhouette and reflects the sky where the ground belongs.\n   */\n  let mirrored = 2.0 * nv * n - surface.toEye;\n  let gradient = mix(env.ground, env.sky, mirrored.y * 0.5 + 0.5);\n  let seen = mix(gradient, env.radiance, env.radianceAmount);\n  let weight = environmentWeight(ndv, roughness, surface.reflectivity, env.prefiltered, metal);\n  /* A metal reflects the room through itself; mix(1, albedo, 0) is exactly 1 for a dielectric. */\n  let reflected = seen * mix(vec3<f32>(1.0), albedo, metal);\n  /* Scaled by the frame and dimmed by a share of the sun's shadow, as flat/main.ts's glow is. */\n  let glow = surface.emissive * env.emission\n    * mix(1.0, surface.shade, 0.55);\n  return (mix(base, reflected, weight) + highlight * metal + surface.emissiveColour * glow)\n    * surface.occlusion;\n}\n\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) id: vec3<u32>) {\n  let count = u32(params[0]);\n  if (id.x >= count) {\n    return;\n  }\n  let at = id.x * 19u;\n  let env = id.x * 22u;\n  var surface: LitSurface;\n  surface.albedo = vec3<f32>(surfaces[at], surfaces[at + 1u], surfaces[at + 2u]);\n  surface.normal = vec3<f32>(surfaces[at + 3u], surfaces[at + 4u], surfaces[at + 5u]);\n  surface.toEye = vec3<f32>(surfaces[at + 6u], surfaces[at + 7u], surfaces[at + 8u]);\n  surface.roughness = surfaces[at + 9u];\n  surface.specular = surfaces[at + 10u];\n  surface.emissive = surfaces[at + 11u];\n  surface.shade = surfaces[at + 12u];\n  surface.reflectivity = surfaces[at + 13u];\n  surface.metalness = surfaces[at + 14u];\n  surface.occlusion = surfaces[at + 15u];\n  surface.emissiveColour = vec3<f32>(surfaces[at + 16u], surfaces[at + 17u], surfaces[at + 18u]);\n\n  var room: LitEnvironment;\n  room.lightDir = vec3<f32>(environment[env], environment[env + 1u], environment[env + 2u]);\n  room.lightColour = vec3<f32>(environment[env + 3u], environment[env + 4u], environment[env + 5u]);\n  room.sky = vec3<f32>(environment[env + 6u], environment[env + 7u], environment[env + 8u]);\n  room.ground = vec3<f32>(environment[env + 9u], environment[env + 10u], environment[env + 11u]);\n  room.irradiance =\n    vec3<f32>(environment[env + 12u], environment[env + 13u], environment[env + 14u]);\n  room.radiance = vec3<f32>(environment[env + 15u], environment[env + 16u], environment[env + 17u]);\n  room.irradianceAmount = environment[env + 18u];\n  room.radianceAmount = environment[env + 19u];\n  room.prefiltered = environment[env + 20u];\n  room.emission = environment[env + 21u];\n\n  let colour = litColour(surface, room);\n  colours[id.x * 3u] = colour.x;\n  colours[id.x * 3u + 1u] = colour.y;\n  colours[id.x * 3u + 2u] = colour.z;\n}\n";
+/** Floats a case of the surface-frame check: n, dp1, dp2, duv1, duv2, size. */
+export declare const SURFACE_FRAME_CASE_FLOATS = 14;
+export declare const SURFACE_FRAME_PARITY_WGSL = "\nstruct Screen {\n  x: f32,\n  y: f32,\n  invW: f32,\n}\n\nstruct Weights {\n  /** The perspective-correct barycentric weights. */\n  c: vec3<f32>,\n  /** How each of them changes with screen x, and with screen y. */\n  gx: vec3<f32>,\n  gy: vec3<f32>,\n  valid: bool,\n}\n\nfn screenOf(clip: vec4<f32>, width: f32, height: f32) -> Screen {\n  let inv = 1.0 / clip.w;\n  var out: Screen;\n  out.x = (clip.x * inv * 0.5 + 0.5) * width;\n  out.y = (clip.y * inv * 0.5 + 0.5) * height;\n  out.invW = inv;\n  return out;\n}\n\nfn surfaceWeights(s0: Screen, s1: Screen, s2: Screen, px: f32, py: f32) -> Weights {\n  var out: Weights;\n  out.valid = false;\n\n  let area = (s1.x - s0.x) * (s2.y - s0.y) - (s2.x - s0.x) * (s1.y - s0.y);\n  if (abs(area) < 1e-12) { return out; }\n  let inverse = 1.0 / area;\n\n  /* Screen-space weights. A point outside the triangle gets a negative one rather than a clamp:\n     clamping shades a pixel beyond an edge as though it were on the triangle. */\n  let l1 = ((px - s0.x) * (s2.y - s0.y) - (s2.x - s0.x) * (py - s0.y)) * inverse;\n  let l2 = ((s1.x - s0.x) * (py - s0.y) - (px - s0.x) * (s1.y - s0.y)) * inverse;\n  let l0 = 1.0 - l1 - l2;\n\n  let n0 = l0 * s0.invW;\n  let n1 = l1 * s1.invW;\n  let n2 = l2 * s2.invW;\n  let sum = n0 + n1 + n2;\n  if (abs(sum) < 1e-20) { return out; }\n  let invSum = 1.0 / sum;\n  out.c = vec3<f32>(n0 * invSum, n1 * invSum, n2 * invSum);\n\n  /* The screen weights' gradients, constant over the triangle. */\n  let d1dx = (s2.y - s0.y) * inverse;\n  let d1dy = (s0.x - s2.x) * inverse;\n  let d2dx = (s0.y - s1.y) * inverse;\n  let d2dy = (s1.x - s0.x) * inverse;\n  let d0dx = -d1dx - d2dx;\n  let d0dy = -d1dy - d2dy;\n\n  let dSumDx = d0dx * s0.invW + d1dx * s1.invW + d2dx * s2.invW;\n  let dSumDy = d0dy * s0.invW + d1dy * s1.invW + d2dy * s2.invW;\n\n  /* Quotient rule, per weight, with the shared denominator factored out. */\n  out.gx = vec3<f32>(\n    (d0dx * s0.invW - n0 * invSum * dSumDx) * invSum,\n    (d1dx * s1.invW - n1 * invSum * dSumDx) * invSum,\n    (d2dx * s2.invW - n2 * invSum * dSumDx) * invSum,\n  );\n  out.gy = vec3<f32>(\n    (d0dy * s0.invW - n0 * invSum * dSumDy) * invSum,\n    (d1dy * s1.invW - n1 * invSum * dSumDy) * invSum,\n    (d2dy * s2.invW - n2 * invSum * dSumDy) * invSum,\n  );\n  out.valid = true;\n  return out;\n}\n\n/* surfaceFrame.ts surfaceLod: the longer screen-axis UV step, in texels, as a power of two. */\nfn surfaceLod(gradX: vec2<f32>, gradY: vec2<f32>, size: f32) -> f32 {\n  let footprint = max(length(gradX), length(gradY)) * size;\n  return max(log2(max(footprint, 1e-30)), 0.0);\n}\n\nstruct TangentFrame {\n  t: vec3<f32>,\n  b: vec3<f32>,\n}\n\n/* surfaceFrame.ts derivedTangentFrame, which is tangentFrame.ts's derived branch term for term. */\nfn derivedTangentFrame(\n  n: vec3<f32>,\n  dp1: vec3<f32>,\n  dp2: vec3<f32>,\n  duv1: vec2<f32>,\n  duv2: vec2<f32>,\n) -> TangentFrame {\n  let dp2perp = cross(dp2, n);\n  let dp1perp = cross(n, dp1);\n  let dt = dp2perp * duv1.x + dp1perp * duv2.x;\n  let db = dp2perp * duv1.y + dp1perp * duv2.y;\n  let det = duv1.x * duv2.y - duv2.x * duv1.y;\n  let handed = select(1.0, -1.0, det < 0.0);\n  let scale = inverseSqrt(max(max(dot(dt, dt), dot(db, db)), 1e-12)) * handed;\n  var frame: TangentFrame;\n  frame.t = dt * scale;\n  frame.b = db * scale;\n  return frame;\n}\n\n@group(0) @binding(0) var<storage, read> params: array<f32>;\n@group(0) @binding(1) var<storage, read> cases: array<f32>;\n@group(0) @binding(2) var<storage, read_write> results: array<f32>;\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) id: vec3<u32>) {\n  if (id.x >= u32(params[0])) {\n    return;\n  }\n  let at = id.x * 14u;\n  let n = vec3<f32>(cases[at], cases[at + 1u], cases[at + 2u]);\n  let dp1 = vec3<f32>(cases[at + 3u], cases[at + 4u], cases[at + 5u]);\n  let dp2 = vec3<f32>(cases[at + 6u], cases[at + 7u], cases[at + 8u]);\n  let duv1 = vec2<f32>(cases[at + 9u], cases[at + 10u]);\n  let duv2 = vec2<f32>(cases[at + 11u], cases[at + 12u]);\n  let frame = derivedTangentFrame(n, dp1, dp2, duv1, duv2);\n  let dst = id.x * 7u;\n  results[dst] = surfaceLod(duv1, duv2, cases[at + 13u]);\n  results[dst + 1u] = frame.t.x;\n  results[dst + 2u] = frame.t.y;\n  results[dst + 3u] = frame.t.z;\n  results[dst + 4u] = frame.b.x;\n  results[dst + 5u] = frame.b.y;\n  results[dst + 6u] = frame.b.z;\n}\n";