@woosh/meep-engine 3.11.2 → 3.12.0

package/src/shade/renderer/view/GPUViewSkyContext.js

@@ -1,174 +1,170 @@
-import { m3_cm_compose_transform } from "../../../core/geom/mat3/m3_cm_compose_transform.js";
-import { FrameGraph } from "../../../engine/graphics/render/frame_graph/FrameGraph.js";
-import { Sampler2D } from "../../../engine/graphics/texture/sampler/Sampler2D.js";
-import sampler2d_to_html_canvas
-    from "../../../engine/graphics/texture/sampler/sampler2d_to_html_canvas.js";
-import { writeCssTransformMatrix } from "../../../view/writeCssTransformMatrix.js";
-import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.js";
-import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
-import { SPHERE_PROBE_MIPMAP_LEVELS } from "../light/environment/DEFINES.js";
-import { graph_filter_environment_map } from "../light/environment/graph_filter_environment_map.js";
-import { shader_sky_irradiance_lut } from "../atmosphere/shader_sky_irradiance_lut.js";
-import { graph_image_pass } from "../shader/graph/graph_image_pass.js";
-import { GPUTextureContext } from "../texture/GPUTextureContext.js";
-import { sampler_linear_to_sRGB } from "../texture/sampler_linear_to_sRGB.js";
-
-let debug_counter = 0;
-
-export class GPUViewSkyContext {
-
-
-    /**
-     * @type {GraphicsContext}
-     */
-    #graphics;
-
-    /**
-     * @type {GPUTextureContext}
-     */
-    #lut_sky;
-
-
-    /**
-     *
-     * @returns {GPUTextureContext}
-     */
-    get irradiance_lut() {
-        return this.#lut_sky;
-    }
-
-    /**
-     *
-     * @param {GraphicsContext} graphics
-     */
-    constructor(graphics) {
-        this.#graphics = graphics;
-
-        const device = graphics.device;
-
-        this.#lut_sky = new GPUTextureContext(device);
-        this.#lut_sky.descriptor.label = "Sky / Irradiance LUT";
-        this.#lut_sky.descriptor.format = "rgba16float";
-        this.#lut_sky.descriptor.mipLevelCount = SPHERE_PROBE_MIPMAP_LEVELS;
-        this.#lut_sky.descriptor.usage = GPUTextureUsage.RENDER_ATTACHMENT
-            | GPUTextureUsage.TEXTURE_BINDING
-            | GPUTextureUsage.STORAGE_BINDING
-            | GPUTextureUsage.COPY_SRC
-        ;
-        this.#lut_sky.resize(1024, 1024);
-
-    }
-
-    #needs_update = true;
-
-    set needs_update(v) {
-        if (v) {
-            this.#needs_update = true;
-        }
-    }
-
-    /**
-     *
-     * @param {GPUCameraContext} camera
-     * @param {GPUSceneContext} scene
-     */
-    update(camera, scene) {
-
-        if (!this.#needs_update) {
-            return;
-        }
-
-        this.#needs_update = false;
-
-        // ensure base sky LUTs are up-to-date
-        /**
-         *
-         * @type {GPUSky}
-         */
-        const scene_sky = scene.sky;
-        scene_sky.update();
-
-        const graph = new FrameGraph("sky update");
-
-        const command_ctx = ShadeGPUCommandContext.create(
-            this.#graphics,
-            "Renderer/main"
-        );
-
-        const gr_transmittance = graph.import_resource("transmittance", TextureResourceDescriptor.fromTexture(scene_sky.lut_transmittance.gpu_texture), scene_sky.lut_transmittance);
-        const gr_multiscatter = graph.import_resource("multiscatter", TextureResourceDescriptor.fromTexture(scene_sky.lut_multiple_scattering.gpu_texture), scene_sky.lut_multiple_scattering);
-        const gr_sky = graph.import_resource("sky_irradiance", TextureResourceDescriptor.fromTexture(this.#lut_sky.gpu_texture), this.#lut_sky);
-
-        let [out] = graph_image_pass({
-            graph,
-            shader: shader_sky_irradiance_lut,
-            inputs: {
-                settings: {
-                    steps: 32,
-                },
-
-                camera: camera.buffer,
-
-                light_data: scene.lights.buffer_data,
-
-                tSkyLutTransmittance: gr_transmittance,
-                tSkyLutMultiscatter: gr_multiscatter
-            },
-            output: [gr_sky]
-        });
-
-        // convolve
-        out = graph_filter_environment_map({
-            graph,
-            map: out
-        });
-
-        command_ctx.encodeGraph(graph);
-
-        command_ctx.finish();
-
-        debug_counter++;
-
-
-        // this.debug(3);
-    }
-
-    async debug(mip = 0) {
-        if (this.__debug_waiting) {
-            return;
-        }
-
-        this.__debug_waiting = true;
-
-        const texture = this.#lut_sky;
-
-        const data = await texture.download(mip);
-
-        const s = new Sampler2D(data, 4, texture.size[0] >> mip, texture.size[1] >> mip);
-        sampler_linear_to_sRGB(s);
-
-        const canvas = sampler2d_to_html_canvas(s, 255, 0, this.__debug_canvas);
-
-        if (this.__debug_canvas === undefined) {
-
-            canvas.style.zIndex = "100";
-            canvas.style.position = "absolute";
-            canvas.style.bottom = `${32}px`;
-            canvas.style.right = `${32}px`;
-
-            const transform = new Float32Array(9);
-            m3_cm_compose_transform(transform, 0, 0, 1, -1, 0, 0, 0);
-            writeCssTransformMatrix(transform, canvas);
-
-            document.body.appendChild(canvas);
-        }
-
-        this.__debug_canvas = canvas;
-
-        this.__debug_waiting = false;
-    }
-
-    destroy() {
-        this.#lut_sky.destroy();
-    }
+import { m3_cm_compose_transform } from "../../../core/geom/mat3/m3_cm_compose_transform.js";
+import { FrameGraph } from "../../../engine/graphics/render/frame_graph/FrameGraph.js";
+import { Sampler2D } from "../../../engine/graphics/texture/sampler/Sampler2D.js";
+import sampler2d_to_html_canvas
+    from "../../../engine/graphics/texture/sampler/sampler2d_to_html_canvas.js";
+import { writeCssTransformMatrix } from "../../../view/writeCssTransformMatrix.js";
+import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.js";
+import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
+import { SPHERE_PROBE_MIPMAP_LEVELS } from "../light/environment/DEFINES.js";
+import { graph_filter_environment_map } from "../light/environment/graph_filter_environment_map.js";
+import { shader_sky_irradiance_lut } from "../atmosphere/shader_sky_irradiance_lut.js";
+import { graph_image_pass } from "../shader/graph/graph_image_pass.js";
+import { GPUTextureContext } from "../texture/GPUTextureContext.js";
+import { sampler_linear_to_sRGB } from "../texture/sampler_linear_to_sRGB.js";
+
+let debug_counter = 0;
+
+export class GPUViewSkyContext {
+
+
+    /**
+     * @type {GraphicsContext}
+     */
+    #graphics;
+
+    /**
+     * @type {GPUTextureContext}
+     */
+    #lut_sky;
+
+
+    /**
+     *
+     * @returns {GPUTextureContext}
+     */
+    get irradiance_lut() {
+        return this.#lut_sky;
+    }
+
+    /**
+     *
+     * @param {GraphicsContext} graphics
+     */
+    constructor(graphics) {
+        this.#graphics = graphics;
+
+        const device = graphics.device;
+
+        this.#lut_sky = new GPUTextureContext(device);
+        this.#lut_sky.descriptor.label = "Sky / Irradiance LUT";
+        this.#lut_sky.descriptor.format = "rgba16float";
+        this.#lut_sky.descriptor.mipLevelCount = SPHERE_PROBE_MIPMAP_LEVELS;
+        this.#lut_sky.descriptor.usage = GPUTextureUsage.RENDER_ATTACHMENT
+            | GPUTextureUsage.TEXTURE_BINDING
+            | GPUTextureUsage.STORAGE_BINDING
+            | GPUTextureUsage.COPY_SRC
+        ;
+        this.#lut_sky.resize(1024, 1024);
+
+    }
+
+    #needs_update = true;
+
+    set needs_update(v) {
+        if (v) {
+            this.#needs_update = true;
+        }
+    }
+
+    /**
+     *
+     * @param {GPUCameraContext} camera
+     * @param {GPUSceneContext} scene
+     */
+    update(camera, scene) {
+
+        if (!this.#needs_update) {
+            return;
+        }
+
+        this.#needs_update = false;
+
+        // ensure base sky LUTs are up-to-date
+        /**
+         *
+         * @type {GPUSky}
+         */
+        const scene_sky = scene.sky;
+        scene_sky.update();
+
+        const graph = new FrameGraph("sky update");
+
+        const command_ctx = ShadeGPUCommandContext.create(
+            this.#graphics,
+            "Renderer/main"
+        );
+
+        const gr_transmittance = graph.import_resource("transmittance", TextureResourceDescriptor.fromTexture(scene_sky.lut_transmittance.gpu_texture), scene_sky.lut_transmittance);
+        const gr_multiscatter = graph.import_resource("multiscatter", TextureResourceDescriptor.fromTexture(scene_sky.lut_multiple_scattering.gpu_texture), scene_sky.lut_multiple_scattering);
+        const gr_sky = graph.import_resource("sky_irradiance", TextureResourceDescriptor.fromTexture(this.#lut_sky.gpu_texture), this.#lut_sky);
+
+        let [out] = graph_image_pass({
+            graph,
+            shader: shader_sky_irradiance_lut,
+            inputs: {
+                camera: camera.buffer,
+
+                light_data: scene.lights.buffer_data,
+
+                tSkyLutTransmittance: gr_transmittance,
+                tSkyLutMultiscatter: gr_multiscatter
+            },
+            output: [gr_sky]
+        });
+
+        // convolve
+        out = graph_filter_environment_map({
+            graph,
+            map: out
+        });
+
+        command_ctx.encodeGraph(graph);
+
+        command_ctx.finish();
+
+        debug_counter++;
+
+
+        // this.debug(3);
+    }
+
+    async debug(mip = 0) {
+        if (this.__debug_waiting) {
+            return;
+        }
+
+        this.__debug_waiting = true;
+
+        const texture = this.#lut_sky;
+
+        const data = await texture.download(mip);
+
+        const s = new Sampler2D(data, 4, texture.size[0] >> mip, texture.size[1] >> mip);
+        sampler_linear_to_sRGB(s);
+
+        const canvas = sampler2d_to_html_canvas(s, 255, 0, this.__debug_canvas);
+
+        if (this.__debug_canvas === undefined) {
+
+            canvas.style.zIndex = "100";
+            canvas.style.position = "absolute";
+            canvas.style.bottom = `${32}px`;
+            canvas.style.right = `${32}px`;
+
+            const transform = new Float32Array(9);
+            m3_cm_compose_transform(transform, 0, 0, 1, -1, 0, 0, 0);
+            writeCssTransformMatrix(transform, canvas);
+
+            document.body.appendChild(canvas);
+        }
+
+        this.__debug_canvas = canvas;
+
+        this.__debug_waiting = false;
+    }
+
+    destroy() {
+        this.#lut_sky.destroy();
+    }
 }

package/src/shade/renderer/volumetrics/GPUViewVolumetrics.js

@@ -24,7 +24,7 @@ import { VOLUMETRICS_RESOLUTION_Z } from "./VOLUMETRICS_RESOLUTION_Z.js";
 /**
  * resolution of a single froxel in XY, in pixels
  */
-const TILE_SIZE = 8;
+const TILE_SIZE = 16;
 
 export class GPUViewVolumetrics {
 

package/src/shade/renderer/volumetrics/NOTES.md

@@ -689,3 +689,241 @@ for the march.
   that the metadata wants a real array, whose uniform-space stride is 16 bytes per `f32`.
 - The build is latency-bound, not bandwidth-bound. If it ever has to be cheaper, the lever is the
   serial chain — fewer slices per cascade, or a cooperative scan — and not fewer samples.
+
+## The lighting workgroup, and a premise that did not survive contact — measured, 2026-08-30
+
+S-01. The pass declared `@workgroup_size(16,16)`, dispatched one workgroup per froxel z slice. The
+study's argument for reshaping it: a froxel is `TILE_SIZE` = 8 pixels, so a 16x16 group covers
+128x128 pixels — sixteen separate 32-pixel light clusters — and every lane of a wave can be walking
+a different light list, which is the worst case for the divergent light-record reads in the point
+and spot loops and for shadow atlas tile locality. 4x4 in xy is exactly one cluster tile.
+
+Mean over the build lighting span:
+
+| shape | invocations | clusters spanned | mean |
+|---|---|---|---|
+| 16x16x1 | 256 | 16 in xy | **247 us** |
+| 8x8x1 | 64 | 4 in xy | 368 us |
+| 4x4x4 | 64 | 1 in xy, 4 in z | 386 us |
+
+**The premise was false.** The shape spanning the most clusters is the fastest by 50%, so
+cross-cluster divergence is not what governs this pass's time — cutting the group's cluster
+footprint from sixteen tiles to one made it *slower*, and the xy alignment the whole finding rested
+on bought nothing. Whatever dominates here, it is group size, not light-list coherence.
+
+**Spanning z is separately wrong, and that part holds.** At equal occupancy, 4x4x4 is slower than
+8x8x1. Lights are binned into 3D clusters and the largest distance between neighbouring clusters is
+along depth, so a group that spans z spans the most unrelated light lists — the axis the study
+picked to grow was the one axis to leave alone. The reshape is 2D for the same reason the pass was
+2D to begin with.
+
+Shipping **8x8x1**: 64 invocations, one wave64 or two warps, flat in z. That is 121 us of measured
+cost against the original, paid deliberately, and the reason is **portability**.
+
+Both numbers above were taken on an RTX 4090. Its register file is unusually large, and a 256-invocation
+group winning there says more about that part than about the shape: the wider the group, the more
+registers it needs live at once, and a 4090 has the headroom to keep 256 of them resident where a
+smaller part would drop occupancy instead. AMD hardware in particular does better with smaller
+groups. So 16x16x1's 247 us is a local result, not a general one, and shipping the shape that wins
+on one machine would be tuning the engine to this desk.
+
+Do not read the table as an instruction to put 16x16x1 back. That would need measurements from more
+than one vendor, and it is a different question from the one measured here.
+
+The shape is now `VOLUMETRICS_LIGHTING_WORKGROUP_RESOLUTION`, read by both the `@workgroup_size` and
+the dispatch, following the sun shadow build. Dead `VOLUMETRICS_WORKGROUP_RESOLUTION` (`[8, 8, 4]`,
+zero importers, matching one pass's literal by coincidence) is deleted.
+
+### Regrouping cannot change the output, and did not
+
+Every invocation computes from `global_invocation_id` alone — no shared memory, no subgroup op, no
+cross-invocation state — so the question reduces to which ids get dispatched. Driven through the
+emulator over both id sets, `tLighting` compared equal byte for byte at grids with a partial group
+on one axis, on all three, and on none, with no voxel left unwritten; coverage at 1080p's 240x135x64
+is exactly once each. That harness was throwaway — it compares against shapes that no longer exist —
+and what stayed is a test pinning `@workgroup_size` to the constant the dispatch divides by.
+
+Two things worth keeping from building its negative controls:
+
+- Under-dispatching fails loudly: a stale divisor drops froxels and the volume comes back holed.
+- **Over-dispatching is invisible.** A `group_count_z` left at the slice count under a 4-deep group
+  still visits every voxel exactly once — `gz * 4 + lz` stays a bijection — so the volume is
+  bit-identical while four times the groups launch to bounds-check and return. Only an assertion
+  about the dispatch being tight catches it.
+
+## Hoisting the local-light shadow test above the march — measured and NOT shipped, 2026-08-30
+
+F-01 and F-03, together, because separately neither is worth doing. Both local-light loops in
+`shader_volumetrics_build_lighting` ran march -> multiscatter -> shadow:
+
+```
+let optical_depth = integrate_optical_depth(shadow_ray);   // up to 16 filtered 3D fetches
+let ms = calculate_multiscattering(...);                   // 6 octaves, pow + exp per octave
+let shadow_term = volumetrics_point_light_shadow(...);     // 1 textureLoad, returns 0 or 1
+inScatteringSum += shadow_term * ms * direct_light.color;
+```
+
+The shadow term is binary by construction — `chunk_volumetrics_local_light_shadow` takes one nearest
+texel with no filter kernel and ends in a `select` between 0.0 and 1.0 — so a zero throws away
+everything above it. Testing it first and `continue`ing on zero skips that work (F-01). And
+`volumetrics_point_light_shadow(database, index, position)` re-read the record
+`get_point_light_info_by_index` had just unmarshalled, *before* its `CASTS_SHADOW_BIT` early-out
+could fire, so the reorder alone would have added a storage read for every non-shadowing light;
+passing the struct instead removes the duplicate and makes the flag test free (F-03).
+
+**The reorder is exact, and that was verified rather than argued.** Both orderings were driven
+through the WGSL emulator over thirteen fixtures — every exit of both loops, plus a case with real
+per-froxel extinction where the old order computed a genuine optical depth and multiscatter and then
+multiplied the pair by zero — and `tLighting` compared **byte for byte**, on the raw bits so that
+`+0`/`-0` and any NaN payload would count as a difference. It is identical everywhere. NaN is the one
+input for which the two are not equivalent (`0 * NaN` propagates, a skipped term does not), so the
+spec fails on any non-finite value in its own right instead of folding it into the comparison.
+
+**It is not faster.** Median of the `Volumetrics / build lighting` span over 18 interleaved rounds at
+3840x2160, ABBA-ordered so neither arm systematically takes the warm half of a round, 48 recorded
+frames per capture after a 40-frame ramp:
+
+| arm | median (ms) |
+|---|---|
+| shadow test first (F-01/F-03) | 1.3573 |
+| march first (shipping) | 1.3471 |
+| **median paired difference** | **+0.0108** |
+
+and the same protocol run with the *same build on both arms*, which is what that number has to beat:
+
+| | median paired difference | median abs difference |
+|---|---|---|
+| A/B, 18 rounds | +0.0108 | 0.0998 |
+| **A/A floor, 10 rounds** | **+0.0092** | 0.0456 |
+
+The measured effect and the noise floor agree to 1.6 us. There is no signal, and the sign is the
+wrong one anyway.
+
+**Why there was nothing to win, which is the part worth keeping.** The local-light loops are not a
+measurable part of this pass in this scene at all. Removing all 130 shadow-casting point lights from
+the playground scene and re-measuring:
+
+| | median (ms) |
+|---|---|
+| 130 shadow-casting point lights | 1.2585 |
+| the same scene with all of them removed | 1.3343 |
+
+Deleting the entire workload the finding proposed to optimize does not make the pass faster — it
+reads a shade slower, which is to say the difference is noise. Whatever the 1.3 ms is spent on, it is
+the per-froxel work outside those loops: the STBN fetch, the two participating-media samples, the
+cluster lookup, and the directional loop's cascade fetch. That also retires the premise the finding
+rested on, the same way S-01's did: 130 shadow-casting lights in the scene does not mean 130 lights
+in the cluster any froxel actually reads.
+
+So this joins Q-01's "the cost is nearly nothing" as a cost claim the profiler refused. Not shipped;
+the tree keeps the march-first order.
+
+What would have to change before it is worth revisiting: a scene where the froxel volume genuinely
+overlaps many clustered lights, shown by that removal test moving the number. Reach for the removal
+test *first* next time — it is three captures and it would have settled this before any code was
+written.
+
+Two things did survive, both about the shipping code rather than the change:
+
+- `shader_volumetrics_build_lighting_local_shadow.spec.js` now covers the exits it did not: a light
+  over an atlas region that was never rendered (`stored == 0`, must not occlude), a froxel behind a
+  spot's apex (`clip_light.w <= 0`), that the optical-depth march still runs and still attenuates
+  when the shadow test passes, and that no NaN or infinity reaches `tLighting` in any fixture. The
+  apex case needs a deliberately inconsistent fixture and says so: in the shipping arrangement a
+  froxel behind the apex is also outside the cone, so the range cull `continue`s before the shadow
+  function is reached, and the branch has to be built rather than found.
+
+- The dev server no longer hot-reloads (`server.hmr: false`). A reload drops the WebGPU device and
+  resets the temporal accumulation, and an edit anywhere in the module graph — including one made by
+  someone else working in the tree at the same time, which is exactly what happened here — destroys
+  an interleaved A/B mid-run.
+
+Measurement conditions, because one of them is unusual: RTX 4090, canvas 1280x720 at pixel ratio 3.
+The pass was confirmed resolution-bound first (0.4618 ms at 1280x720 rising to 1.878 ms at 3840x2160)
+rather than presentation-throttled. Another session was building and running GPU work on the same
+machine throughout, which put occasional 2x outliers in both arms; medians absorb them, and the A/A
+floor was taken under the same conditions so it prices them in.
+
+## The participating-media coverage skip — counted and NOT shipped, 2026-08-30
+
+`shader_volumetrics_build_participating_media` carried a TODO: if a froxel is entirely inside a
+volume, coverage is 1.0 and `frustum_unit_box_coverage` need not run. The TODO proposed getting there
+by replacing `aabb3_intersects_frustum` with something that returns an intersection *degree*.
+
+### The degree answers the other question
+
+`aabb3_intersects_frustum(unit_bounds, local_frustum)` classifies the **volume box** against the
+**froxel's planes**, and `aabb3_intersects_frustum_degree` already returns 0/1/2 for exactly that.
+Its `2` means the box is inside the froxel — the arrangement where the froxel is *larger* than the
+volume, where coverage is a small fraction. Reading it as "coverage is 1.0" would flood the far field
+with fog, which `volumetrics_froxel_containment.spec.js` pins as a test.
+
+What coverage of 1.0 needs is the dual: **froxel ⊆ box**. Both bodies are convex, so it holds exactly
+when the froxel's 8 vertices are inside the box, and `frustum_to_corners` produces the same points
+`frustum_sample_point` reaches at `uvw ∈ {0,1}³` — the sign flips in `plane_convex_intersection`
+cancel, so a plane and its negation give the same corner. The test is exact, not conservative, and
+the same bound gives a second exact skip: if the froxel clears `fade_distance` from every face in
+world units, all three of `compute_volume_fade_factor`'s smoothsteps saturate and the fade is 1.0.
+
+### It is exact and it still loses
+
+Corners cost 8 `plane_convex_intersection` — 3 crosses, a dot and a divide each — which is what
+`frustum_unit_box_coverage` spends on its 4 rays. Deriving them per volume pays for precisely the
+work it skips, so the only arrangement that can win builds them once per froxel in world space and
+maps them into each volume with a matrix multiply.
+
+Hit rates over the playground's six volumes at 240x135x64 (every 4th column in X and Y, every slice
+in Z, froxel extents kept at the true 1/240 and 1/135):
+
+| pose | froxels touching a volume | survivors per froxel | contained | fade saturated |
+|---|---|---|---|---|
+| overview (default) | 100.0% | 1.223 | 7.0% | 3.3% |
+| fog bank, wide | 91.2% | 0.912 | 8.1% | 4.1% |
+| inside the fog | 97.6% | 1.565 | 33.2% | 27.2% |
+
+Per froxel, in three-plane intersections:
+
+| pose | paid | saved | |
+|---|---|---|---|
+| overview | 8.00 | 0.77 | **10.4x loss** |
+| fog bank | 8.00 | 0.67 | **12.0x loss** |
+| inside the fog | 8.00 | 5.00 | **1.6x loss** |
+
+Two refinements do not rescue it. Building the corners **lazily**, on the first volume that survives
+the plane test, saves nothing: the 400x20x400 cloud deck is a huge thin slab that defeats the
+conservative frustum/AABB test almost everywhere, so 91-100% of froxels touch a volume anyway.
+Gating on a **1-intersection necessary condition** — the froxel's own centre must be inside the box,
+or containment is impossible — is very tight (centre-inside is 8.7% against contained's 7.0%) and
+still loses: 2.7x, 2.5x and 1.3x on the three poses.
+
+So the geometry is right and the arithmetic is against it, at every pose measured, including the one
+where a third of froxels qualify. Not shipped. `volumetrics_froxel_containment.spec.js` keeps the
+proof — containment implies coverage of exactly 1.0, and the fade core implies a fade of exactly
+1.0 — alongside `chunk_aabb3_contains_aabb3` and `chunk_aabb3_from_transformed_corners`, so if the
+grid, the volume mix or the estimator's cost moves, restoring the early-out is a few lines rather
+than a rediscovery.
+
+This one was settled by counting rather than by the profiler, which is unusual here. The hit rate is
+a property of the scene's geometry and not of the device, and the cost ratio it implies is 2.5x to
+12x on the two poses that matter — far outside anything a capture would overturn. A GPU A/B is the
+confirmation, not the decision.
+
+### What did ship
+
+The line above the TODO was doing real redundant work. `frustum_transform_m4(froxel_frustum,
+volume.transform_inverse)` derives its plane matrix as `transpose(mat4_inverse(transform))`, so
+handing it `transform_inverse` made it compute `transpose(mat4_inverse(transform_inverse))` — which
+is `transpose(volume.transform)`, a matrix already resident in the struct. Every froxel/volume pair
+was running the 85-line generic cofactor `mat4_inverse` to recover a matrix it had been given: at
+1080p with six volumes, 12.4M of them per frame.
+
+`chunk_frustum_transform_plane_matrix` is that function with the plane matrix passed in, and
+`frustum_transform_m4` is now the wrapper that derives one. The shader calls the former with
+`transpose(volume.transform)`. Strictly less work, and marginally more accurate for dropping an
+inverse round-trip. It is a full 4x4, not a 3x3 normal basis: the last row carries the translation,
+which is what supplies each transformed plane's distance term, and
+`chunk_frustum_transform_plane_matrix.spec.js` asserts both that and the equality with the old route.
+
+`transpose` was missing from the WGSL emulator's language core, which is why `frustum_transform_m4`
+had never been exercised there; it is implemented now for the square matrix sizes, on the same
+footing as `determinant`.