@woosh/meep-engine 3.11.3 → 3.12.0

package/src/shade/renderer/texture/virtual/build_shader_vt_feedback.js

@@ -1,232 +1,231 @@
-import { atomic_u32, f32, u32, vec2u } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-import { GEOMETRY_ATTRIBUTE_DATA_TYPE } from "../../geometry/GEOMETRY_ATTRIBUTE_DATA_TYPE.js";
-import { MESHLET_METADATA_STRUCT } from "../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
-import {
-    VIZ_BUFFER_INVALID_MESH_VALUE
-} from "../../rasterize/native/viz/VIZ_BUFFER_INVALID_MESH_VALUE.js";
-import { MATERIAL_METADATA_STRUCT } from "../../material/MATERIAL_METADATA_STRUCT.js";
-import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
-import { RENDER_GLOBAL_MIP_BIAS } from "../../postprocess/taa/RENDER_GLOBAL_MIP_BIAS.js";
-import { chunk_barycentric_full } from "../../shader/chunk/geometry/triangle/chunk_barycentric_full.js";
-import { chunk_barycentric_interpolate_uv } from "../../shader/chunk/geometry/triangle/chunk_barycentric_interpolate_uv.js";
-import { chunk_decode_meshlet_element } from "../../shader/chunk/geometry/meshlet/chunk_decode_meshlet_element.js";
-import {
-    chunk_read_meshlet_triangle_vertices
-} from "../../shader/chunk/geometry/meshlet/chunk_read_meshlet_triangle_vertices.js";
-import { chunk_hash_lowbias32 } from "../../shader/chunk/random/chunk_hash_lowbias32.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { VIEW_UNIFORM_STRUCT } from "../../view/VIEW_UNIFORM_STRUCT.js";
-import { chunk_vt_request_key } from "./chunk_vt_request_key.js";
-import { VT_STACK_ID_INVALID } from "./VT_CONSTANTS.js";
-import { VT_STACK_INFO_STRUCT } from "./VT_STACK_INFO_STRUCT.js";
-
-/**
- * Uniform parameters of the feedback pass.
- *
- * `stride` — the pass samples one pixel per stride×stride block;
- * `jitter` — which pixel of the block this frame (cycled by the manager so
- * coverage integrates to every pixel over stride² frames);
- * `mip_bias` — added to the requested LOD; carries the residency
- * (over-subscription) bias so pressure degrades to blur instead of thrash.
- */
-export const VT_FEEDBACK_PARAMS_STRUCT = WebGPUStruct.from({
-    stride: u32,
-    jitter: vec2u,
-    mip_bias: f32,
-}, "VTFeedbackParams").pack();
-
-/**
- * Matches the fragment_gbuffer derivative bias so feedback requests the mips
- * the material pass actually samples.
- * @type {number}
- */
-const MIP_DERIVATIVE_BIAS = 1 / (1 - RENDER_GLOBAL_MIP_BIAS);
-
-export const VT_FEEDBACK_WORKGROUP_SIZE = 8;
-
-/**
- * Builds the feedback compute shader: one thread per sampled pixel, reading
- * the visibility buffer and reproducing the material pass's UV + analytic
- * gradient math (vertex pulling + perspective-correct barycentric
- * derivatives), then inserting the touched (stack, mip, page) key into a
- * global hash set of unique requests.
- *
- * This is the "no second geometry pass" property: the viz buffer already
- * identifies the triangle per pixel, so usage detection is a bounded-cost
- * screen-space compute pass regardless of scene complexity, shared by every
- * virtual texture in the frame.
- *
- * The hash set is insert-only and cleared each frame; the CPU reads the raw
- * table back and treats presence as "touched this frame" — both residency
- * touches (LRU) and misses (load requests) fall out of the same data.
- *
- * @param {Object} config
- * @param {CodeChunk} config.chunk_vt_lookup from {@link build_chunk_vt_lookup}
- * @param {number} config.hash_capacity power of two
- * @returns {ComputeShader}
- */
-export function build_shader_vt_feedback({ chunk_vt_lookup, hash_capacity }) {
-
-    const resources = new ShaderResourceSetDescriptor();
-
-    resources.createGroup()
-        .addTexture("viz_buffer_triangle", "uint")
-        .addTexture("viz_buffer_mesh", "uint")
-        .addUniform("view", VIEW_UNIFORM_STRUCT)
-        .addUniform("vt_params", VT_FEEDBACK_PARAMS_STRUCT)
-        .addStorageBuffer("scene_database", WebGPUArray.from(u32))
-        .addStorageBuffer("meshlet_metadata", WebGPUArray.from(MESHLET_METADATA_STRUCT))
-        .addStorageBuffer("meshlet_data", GEOMETRY_ATTRIBUTE_DATA_TYPE)
-        .addStorageBuffer("material_metadata", WebGPUArray.from(MATERIAL_METADATA_STRUCT))
-        .addStorageBuffer("vt_stacks", WebGPUArray.from(VT_STACK_INFO_STRUCT))
-        .addStorageBuffer("vt_requests", WebGPUArray.from(atomic_u32), true);
-
-    const body = CodeChunk.from(
-        //language=WGSL
-        `
-const VT_HASH_CAPACITY_MASK: u32 = ${hash_capacity - 1}u;
-const VT_HASH_MAX_PROBES: u32 = 32u;
-
-const MIP_BIAS: f32 = ${MIP_DERIVATIVE_BIAS.toFixed(8)};
-
-// Insert-only open-addressing hash set. Values are stored as key+1 so a
-// zero-cleared buffer means "all empty" (same conventions as
-// common/hash_table, which is the CPU-build/GPU-read counterpart of this
-// GPU-insert/CPU-read set; see also the SHARC hash map for the bucketed
-// key->index variant).
-//
-// Forward-progress note: this loop never waits on another invocation's
-// progress. The atomicCompareExchangeWeak retry only re-tests a *local*
-// spurious failure, every iteration consumes the shared probe budget, and
-// the loop is hard-bounded at VT_HASH_MAX_PROBES regardless of what other
-// threads do. On exhaustion the fallback is to DROP the request — benign,
-// feedback re-emits it next frame. Contrast with the decoupled-lookback
-// spin in common/prefix_sum/v1/shader_prefix_scan_csdldf.js, where the
-// awaited value is required for correctness and the bounded spin
-// (MAX_SPIN_COUNT) must therefore pair with a local recompute fallback.
-fn vt_request_insert(key: u32) {
-    let stored = key + 1u;
-
-    var h = hash_lowbias32(key) & VT_HASH_CAPACITY_MASK;
-
-    for (var i = 0u; i < VT_HASH_MAX_PROBES; i++) {
-        let existing = atomicLoad(&vt_requests[h]);
-
-        if (existing == stored) {
-            return;
-        }
-
-        if (existing == 0u) {
-            let r = atomicCompareExchangeWeak(&vt_requests[h], 0u, stored);
-
-            if (r.exchanged || r.old_value == stored) {
-                return;
-            }
-
-            if (r.old_value == 0u) {
-                // spurious weak failure — retry the same slot
-                continue;
-            }
-        }
-
-        h = (h + 1u) & VT_HASH_CAPACITY_MASK;
-    }
-}
-
-@compute @workgroup_size(${VT_FEEDBACK_WORKGROUP_SIZE}, ${VT_FEEDBACK_WORKGROUP_SIZE}, 1)
-fn main(
-    @builtin(global_invocation_id) gid: vec3<u32>,
-) {
-    let pixel = gid.xy * vt_params.stride + vt_params.jitter;
-
-    if (pixel.x >= view.width || pixel.y >= view.height) {
-        return;
-    }
-
-    let mesh_index = textureLoad(viz_buffer_mesh, vec2<i32>(pixel), 0).r;
-
-    if (mesh_index == ${VIZ_BUFFER_INVALID_MESH_VALUE}u) {
-        return;
-    }
-
-    let mesh = scene_read_mesh(&scene_database, mesh_index);
-
-    let stack_id = material_metadata[mesh.material].vt_stack;
-
-    if (stack_id == ${VT_STACK_ID_INVALID}u) {
-        return;
-    }
-
-    let info = vt_stacks[stack_id];
-
-    // ── UV + gradients, mirroring fragment_gbuffer ──────────────────
-    let encoded_meshlet_triangle = textureLoad(viz_buffer_triangle, vec2<i32>(pixel), 0).r;
-
-    let decoded = decode_meshlet_element(encoded_meshlet_triangle);
-    let meshlet_id = decoded[0];
-    let meshlet_triangle_id = decoded[1];
-
-    let node = scene_read_node(&scene_database, mesh.node);
-
-    let triangle = read_meshlet_triangle_vertices(meshlet_id, meshlet_triangle_id);
-
-    let mesh_transform = node.global;
-
-    let p0 = view.projection_matrix * (mesh_transform * vec4<f32>(triangle.a.position, 1.0));
-    let p1 = view.projection_matrix * (mesh_transform * vec4<f32>(triangle.b.position, 1.0));
-    let p2 = view.projection_matrix * (mesh_transform * vec4<f32>(triangle.c.position, 1.0));
-
-    let pixel_center = vec2<f32>(pixel) + 0.5;
-
-    let barycentric = barycentric_full(p0, p1, p2, pixel_center);
-
-    var uv0 = triangle.a.uv;
-    var uv1 = triangle.b.uv;
-    var uv2 = triangle.c.uv;
-
-    if ((info.flags & VT_STACK_FLAG_UV_SET_1) != 0u) {
-        uv0 = triangle.a.uv1;
-        uv1 = triangle.b.uv1;
-        uv2 = triangle.c.uv1;
-    }
-
-    var uv_info = barycentric_interpolate_uv(barycentric, uv0, uv1, uv2);
-
-    let uv_derivative_bias = MIP_BIAS / view.upscale_ratio;
-
-    uv_info.ddx *= uv_derivative_bias.x;
-    uv_info.ddy *= uv_derivative_bias.y;
-
-    // ── request ─────────────────────────────────────────────────────
-    let uv_wrapped = vt_stack_wrap_uv(uv_info.uv, info.flags);
-
-    let mip = vt_mip_select(info, uv_info.ddx, uv_info.ddy, vt_params.mip_bias);
-
-    let page = vt_page_coord(info, uv_wrapped, mip);
-
-    vt_request_insert(vt_request_key_pack(stack_id, mip, page));
-}
-`,
-        [
-            chunk_vt_lookup,
-            chunk_vt_request_key,
-            chunk_hash_lowbias32,
-            chunk_scene_database_access,
-            chunk_decode_meshlet_element,
-            chunk_read_meshlet_triangle_vertices,
-            chunk_barycentric_full,
-            chunk_barycentric_interpolate_uv,
-        ]
-    );
-
-    return ComputeShader.from({
-        label: 'vt/feedback',
-        body,
-        resources,
-        group_size: [VT_FEEDBACK_WORKGROUP_SIZE, VT_FEEDBACK_WORKGROUP_SIZE, 1],
-    });
-}
+import { atomic_u32, f32, u32, vec2u } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { GEOMETRY_ATTRIBUTE_DATA_TYPE } from "../../geometry/GEOMETRY_ATTRIBUTE_DATA_TYPE.js";
+import { MESHLET_METADATA_STRUCT } from "../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
+import {
+    VIZ_BUFFER_INVALID_MESH_VALUE
+} from "../../rasterize/native/viz/VIZ_BUFFER_INVALID_MESH_VALUE.js";
+import { MATERIAL_METADATA_STRUCT } from "../../material/MATERIAL_METADATA_STRUCT.js";
+import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
+import { RENDER_GLOBAL_MIP_BIAS } from "../../postprocess/taa/RENDER_GLOBAL_MIP_BIAS.js";
+import { chunk_barycentric_full } from "../../shader/chunk/geometry/triangle/chunk_barycentric_full.js";
+import { chunk_barycentric_interpolate_uv } from "../../shader/chunk/geometry/triangle/chunk_barycentric_interpolate_uv.js";
+import { chunk_decode_meshlet_element } from "../../shader/chunk/geometry/meshlet/chunk_decode_meshlet_element.js";
+import {
+    chunk_read_meshlet_triangle_vertices
+} from "../../shader/chunk/geometry/meshlet/chunk_read_meshlet_triangle_vertices.js";
+import { chunk_hash_lowbias32 } from "../../shader/chunk/random/chunk_hash_lowbias32.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { VIEW_UNIFORM_STRUCT } from "../../view/VIEW_UNIFORM_STRUCT.js";
+import { chunk_vt_request_key } from "./chunk_vt_request_key.js";
+import { VT_STACK_ID_INVALID } from "./VT_CONSTANTS.js";
+import { VT_STACK_INFO_STRUCT } from "./VT_STACK_INFO_STRUCT.js";
+
+/**
+ * Uniform parameters of the feedback pass.
+ *
+ * `stride` — the pass samples one pixel per stride×stride block;
+ * `jitter` — which pixel of the block this frame (cycled by the manager so
+ * coverage integrates to every pixel over stride² frames);
+ * `mip_bias` — added to the requested LOD; carries the residency
+ * (over-subscription) bias so pressure degrades to blur instead of thrash.
+ */
+export const VT_FEEDBACK_PARAMS_STRUCT = WebGPUStruct.from({
+    stride: u32,
+    jitter: vec2u,
+    mip_bias: f32,
+}, "VTFeedbackParams").pack();
+
+/**
+ * Matches the fragment_gbuffer derivative bias so feedback requests the mips
+ * the material pass actually samples.
+ * @type {number}
+ */
+const MIP_DERIVATIVE_BIAS = 1 / (1 - RENDER_GLOBAL_MIP_BIAS);
+
+export const VT_FEEDBACK_WORKGROUP_SIZE = 8;
+
+/**
+ * Builds the feedback compute shader: one thread per sampled pixel, reading
+ * the visibility buffer and reproducing the material pass's UV + analytic
+ * gradient math (vertex pulling + perspective-correct barycentric
+ * derivatives), then inserting the touched (stack, mip, page) key into a
+ * global hash set of unique requests.
+ *
+ * This is the "no second geometry pass" property: the viz buffer already
+ * identifies the triangle per pixel, so usage detection is a bounded-cost
+ * screen-space compute pass regardless of scene complexity, shared by every
+ * virtual texture in the frame.
+ *
+ * The hash set is insert-only and cleared each frame; the CPU reads the raw
+ * table back and treats presence as "touched this frame" — both residency
+ * touches (LRU) and misses (load requests) fall out of the same data.
+ *
+ * @param {Object} config
+ * @param {CodeChunk} config.chunk_vt_lookup from {@link build_chunk_vt_lookup}
+ * @param {number} config.hash_capacity power of two
+ * @returns {ComputeShader}
+ */
+export function build_shader_vt_feedback({ chunk_vt_lookup, hash_capacity }) {
+
+    const resources = new ShaderResourceSetDescriptor();
+
+    resources.createGroup()
+        .addTexture("viz_buffer_triangle", "uint")
+        .addTexture("viz_buffer_mesh", "uint")
+        .addUniform("view", VIEW_UNIFORM_STRUCT)
+        .addUniform("vt_params", VT_FEEDBACK_PARAMS_STRUCT)
+        .addStorageBuffer("scene_database", WebGPUArray.from(u32))
+        .addStorageBuffer("meshlet_metadata", WebGPUArray.from(MESHLET_METADATA_STRUCT))
+        .addStorageBuffer("meshlet_data", GEOMETRY_ATTRIBUTE_DATA_TYPE)
+        .addStorageBuffer("material_metadata", WebGPUArray.from(MATERIAL_METADATA_STRUCT))
+        .addStorageBuffer("vt_stacks", WebGPUArray.from(VT_STACK_INFO_STRUCT))
+        .addStorageBuffer("vt_requests", WebGPUArray.from(atomic_u32), true);
+
+    const body = CodeChunk.from(
+        //language=WGSL
+        `
+const VT_HASH_CAPACITY_MASK: u32 = ${hash_capacity - 1}u;
+const VT_HASH_MAX_PROBES: u32 = 32u;
+
+const MIP_BIAS: f32 = ${MIP_DERIVATIVE_BIAS.toFixed(8)};
+
+// Insert-only open-addressing hash set. Values are stored as key+1 so a
+// zero-cleared buffer means "all empty" (same conventions as
+// common/hash_table, which is the CPU-build/GPU-read counterpart of this
+// GPU-insert/CPU-read set; see also the SHARC hash map for the bucketed
+// key->index variant).
+//
+// Forward-progress note: this loop never waits on another invocation's
+// progress. The atomicCompareExchangeWeak retry only re-tests a *local*
+// spurious failure, every iteration consumes the shared probe budget, and
+// the loop is hard-bounded at VT_HASH_MAX_PROBES regardless of what other
+// threads do. On exhaustion the fallback is to DROP the request — benign,
+// feedback re-emits it next frame. Contrast with the decoupled-lookback
+// spin in common/prefix_sum/v1/shader_prefix_scan_csdldf.js, where the
+// awaited value is required for correctness and the bounded spin
+// (MAX_SPIN_COUNT) must therefore pair with a local recompute fallback.
+fn vt_request_insert(key: u32) {
+    let stored = key + 1u;
+
+    var h = hash_lowbias32(key) & VT_HASH_CAPACITY_MASK;
+
+    for (var i = 0u; i < VT_HASH_MAX_PROBES; i++) {
+        let existing = atomicLoad(&vt_requests[h]);
+
+        if (existing == stored) {
+            return;
+        }
+
+        if (existing == 0u) {
+            let r = atomicCompareExchangeWeak(&vt_requests[h], 0u, stored);
+
+            if (r.exchanged || r.old_value == stored) {
+                return;
+            }
+
+            if (r.old_value == 0u) {
+                // spurious weak failure — retry the same slot
+                continue;
+            }
+        }
+
+        h = (h + 1u) & VT_HASH_CAPACITY_MASK;
+    }
+}
+
+@compute @workgroup_size(${VT_FEEDBACK_WORKGROUP_SIZE}, ${VT_FEEDBACK_WORKGROUP_SIZE}, 1)
+fn main(
+    @builtin(global_invocation_id) gid: vec3<u32>,
+) {
+    let pixel = gid.xy * vt_params.stride + vt_params.jitter;
+
+    if (pixel.x >= view.width || pixel.y >= view.height) {
+        return;
+    }
+
+    let mesh_index = textureLoad(viz_buffer_mesh, vec2<i32>(pixel), 0).r;
+
+    if (mesh_index == ${VIZ_BUFFER_INVALID_MESH_VALUE}u) {
+        return;
+    }
+
+    let mesh = scene_read_mesh(&scene_database, mesh_index);
+
+    let stack_id = material_metadata[mesh.material].vt_stack;
+
+    if (stack_id == ${VT_STACK_ID_INVALID}u) {
+        return;
+    }
+
+    let info = vt_stacks[stack_id];
+
+    // ── UV + gradients, mirroring fragment_gbuffer ──────────────────
+    let encoded_meshlet_triangle = textureLoad(viz_buffer_triangle, vec2<i32>(pixel), 0).r;
+
+    let decoded = decode_meshlet_element(encoded_meshlet_triangle);
+    let meshlet_id = decoded[0];
+    let meshlet_triangle_id = decoded[1];
+
+    let node = scene_read_node(&scene_database, mesh.node);
+
+    let triangle = read_meshlet_triangle_vertices(meshlet_id, meshlet_triangle_id);
+
+    let mesh_transform = node.global;
+
+    let p0 = view.projection_matrix * (mesh_transform * vec4<f32>(triangle.a.position, 1.0));
+    let p1 = view.projection_matrix * (mesh_transform * vec4<f32>(triangle.b.position, 1.0));
+    let p2 = view.projection_matrix * (mesh_transform * vec4<f32>(triangle.c.position, 1.0));
+
+    let pixel_center = vec2<f32>(pixel) + 0.5;
+
+    let barycentric = barycentric_full(p0, p1, p2, pixel_center);
+
+    var uv0 = triangle.a.uv;
+    var uv1 = triangle.b.uv;
+    var uv2 = triangle.c.uv;
+
+    if ((info.flags & VT_STACK_FLAG_UV_SET_1) != 0u) {
+        uv0 = triangle.a.uv1;
+        uv1 = triangle.b.uv1;
+        uv2 = triangle.c.uv1;
+    }
+
+    var uv_info = barycentric_interpolate_uv(barycentric, uv0, uv1, uv2);
+
+    let uv_derivative_bias = MIP_BIAS / view.upscale_ratio;
+
+    uv_info.ddx *= uv_derivative_bias.x;
+    uv_info.ddy *= uv_derivative_bias.y;
+
+    // ── request ─────────────────────────────────────────────────────
+    let uv_wrapped = vt_stack_wrap_uv(uv_info.uv, info.flags);
+
+    let mip = vt_mip_select(info, uv_info.ddx, uv_info.ddy, vt_params.mip_bias);
+
+    let page = vt_page_coord(info, uv_wrapped, mip);
+
+    vt_request_insert(vt_request_key_pack(stack_id, mip, page));
+}
+`,
+        [
+            chunk_vt_lookup,
+            chunk_vt_request_key,
+            chunk_hash_lowbias32,
+            chunk_scene_database_access,
+            chunk_decode_meshlet_element,
+            chunk_read_meshlet_triangle_vertices,
+            chunk_barycentric_full,
+            chunk_barycentric_interpolate_uv,
+        ]
+    );
+
+    return ComputeShader.from({
+        label: 'vt/feedback',
+        body,
+        resources,
+    });
+}

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/graph_build_volumetrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_build_volumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/graph_build_volumetrics.js"],"names":[],"mappings":"AA4BA;;;;;;;GAOG;AACH,4DAFa;IAAC,iBAAiB,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAA;CAAC,CAgEjE;AAqTD;;;;;;;;;;;;;;;;;;GAkBG;AACH;;;;;EAwKC"}
+{"version":3,"file":"graph_build_volumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/graph_build_volumetrics.js"],"names":[],"mappings":"AAyBA;;;;;;;GAOG;AACH,4DAFa;IAAC,iBAAiB,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAA;CAAC,CAgEjE;AAqTD;;;;;;;;;;;;;;;;;;GAkBG;AACH;;;;;EAwKC"}

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

@@ -9,10 +9,7 @@ import { SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR } from "../shadow/map/SHADOWMAP_CO
 import { STATIC_GRAPHICS_ENGINE_ASSETS } from "../STATIC_GRAPHICS_ENGINE_ASSETS.js";
 import { DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR } from "../texture/DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR.js";
 import { volumetrics_sun_shadow_texture_name } from "./chunk_volumetrics_sun_optical_depth.js";
-import {
-    shader_volumetrics_build_lighting,
-    VOLUMETRICS_LIGHTING_WORKGROUP_RESOLUTION
-} from "./shader_volumetrics_build_lighting.js";
+import { shader_volumetrics_build_lighting } from "./shader_volumetrics_build_lighting.js";
 import { shader_volumetrics_build_participating_media } from "./shader_volumetrics_build_participating_media.js";
 import { shader_volumetrics_build_scattering_lut } from "./shader_volumetrics_build_scattering_lut.js";
 import {
@@ -144,11 +141,11 @@ function graph_integrate_participating_media({
 
             const volumetrics_metadata = resources.get(data.volumetrics_metadata);
 
-            shader_volumetrics_build_participating_media.dispatch({
+            shader_volumetrics_build_participating_media.dispatchThreads({
                 encoder,
-                group_count_x: Math.ceil(output0.width / 16),
-                group_count_y: Math.ceil(output0.height / 16),
-                group_count_z: output0.depth,
+                thread_count_x: output0.width,
+                thread_count_y: output0.height,
+                thread_count_z: output0.depth,
                 bindings: {
                     camera: camera.buffer.buffer,
                     view: view.uniform_buffer.buffer,
@@ -371,11 +368,11 @@ function graph_integrate_light_scattering({
             bindings[volumetrics_sun_shadow_texture_name(cascade)] = sun_shadow_cascades[cascade].obtainView();
         }
 
-        shader_volumetrics_build_lighting.dispatch({
+        shader_volumetrics_build_lighting.dispatchThreads({
             encoder,
-            group_count_x: Math.ceil(output.width / VOLUMETRICS_LIGHTING_WORKGROUP_RESOLUTION[0]),
-            group_count_y: Math.ceil(output.height / VOLUMETRICS_LIGHTING_WORKGROUP_RESOLUTION[1]),
-            group_count_z: Math.ceil(output.depth / VOLUMETRICS_LIGHTING_WORKGROUP_RESOLUTION[2]),
+            thread_count_x: output.width,
+            thread_count_y: output.height,
+            thread_count_z: output.depth,
             bindings
         })
     });
@@ -538,10 +535,10 @@ export function graph_build_volumetrics({
 
         const tSTBN_vec3 = graphics.textures.obtain(STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec3);
 
-        shader_volumetrics_build_scattering_lut.dispatch({
+        shader_volumetrics_build_scattering_lut.dispatchThreads({
             encoder,
-            group_count_x: Math.ceil(output.width / 16),
-            group_count_y: Math.ceil(output.height / 16),
+            thread_count_x: output.width,
+            thread_count_y: output.height,
             bindings: {
                 camera: camera.buffer.buffer,
                 view: view.uniform_buffer.buffer,

package/src/shade/renderer/volumetrics/shader_volumetrics_build_lighting.d.ts

@@ -1,6 +1,7 @@
 /**
- * Workgroup shape of this pass, `[x, y, z]` in froxels, read by both the `@workgroup_size` below
- * and the dispatch in `graph_build_volumetrics` so the two cannot drift.
+ * Workgroup shape of this pass, `[x, y, z]` in froxels, stated to the `@workgroup_size` below.
+ * That attribute is where the dispatch gets the shape from in turn: `graph_build_volumetrics` asks
+ * for a thread count and `ComputeShader` divides by the size it read back out of the WGSL.
  *
  * Flat in z. Lights are binned into 3D clusters and the largest distance between neighbouring
  * clusters is along depth, so a group spanning z is the one spanning the most unrelated light

package/src/shade/renderer/volumetrics/shader_volumetrics_build_lighting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_volumetrics_build_lighting.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_lighting.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;;;;;GAcG;AACH,wDAFU,MAAM,EAAE,CAEiD;AAkXnE,8DAIE;8BA9Z4B,4BAA4B"}
+{"version":3,"file":"shader_volumetrics_build_lighting.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_lighting.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;;;;;;GAeG;AACH,wDAFU,MAAM,EAAE,CAEiD;AAkXnE,8DAIE;8BA/Z4B,4BAA4B"}

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

@@ -44,8 +44,9 @@ import { chunk_volumetrics_local_light_shadow } from "./chunk_volumetrics_local_
 import { VOLUMETRICS_METADATA_STRUCT } from "./VOLUMETRICS_METADATA_STRUCT.js";
 
 /**
- * Workgroup shape of this pass, `[x, y, z]` in froxels, read by both the `@workgroup_size` below
- * and the dispatch in `graph_build_volumetrics` so the two cannot drift.
+ * Workgroup shape of this pass, `[x, y, z]` in froxels, stated to the `@workgroup_size` below.
+ * That attribute is where the dispatch gets the shape from in turn: `graph_build_volumetrics` asks
+ * for a thread count and `ComputeShader` divides by the size it read back out of the WGSL.
  *
  * Flat in z. Lights are binned into 3D clusters and the largest distance between neighbouring
  * clusters is along depth, so a group spanning z is the one spanning the most unrelated light

package/src/shade/renderer/volumetrics/taa/shader_volumetrics_taa.d.ts

@@ -1,5 +1,3 @@
-export const chunk_volumetrics_froxel_coord_to_uvw: CodeChunk;
 export const shader_volumetrics_taa: ComputeShader;
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 //# sourceMappingURL=shader_volumetrics_taa.d.ts.map

package/src/shade/renderer/volumetrics/taa/shader_volumetrics_taa.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_volumetrics_taa.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/taa/shader_volumetrics_taa.js"],"names":[],"mappings":"AA0FA,8DAsCC;AA+LD,mDAIG;0BA1TuB,oCAAoC;8BAChC,+BAA+B"}
+{"version":3,"file":"shader_volumetrics_taa.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/taa/shader_volumetrics_taa.js"],"names":[],"mappings":"AA0UA,mDAIG;8BApU2B,+BAA+B"}

package/src/shade/renderer/volumetrics/taa/shader_volumetrics_taa.js

@@ -88,10 +88,23 @@ fn texture_sample_blackman_harris_3d(
     [chunk_filter_blackman_harris229]
 );
 
-export const chunk_volumetrics_froxel_coord_to_uvw = CodeChunk.from(
+/**
+ * Froxel coordinate -> a sample point for `frustum_sample_point`, NOT a froxel texture coordinate.
+ *
+ * That distinction is the whole reason this is not `volumetrics_position_world_to_froxel_uvw`
+ * turned around. There `w` is slice space -- `log2(fma(depth, x, y)) * z`, corrected by the
+ * cell-averaged content offset -- because it addresses the 3D texture. Here `w` is a LINEAR
+ * fraction of the near..far range, because its only consumer is `frustum_sample_point`, which
+ * mixes the near and far planes linearly. The two agree at the endpoints and nowhere between, so
+ * feeding this `w` to a froxel textureSample reads the wrong slab.
+ *
+ * @see volumetrics_position_world_to_froxel_uvw
+ * @type {CodeChunk}
+ */
+const chunk_volumetrics_froxel_coord_to_frustum_uvw = CodeChunk.from(
     //language=WGSL
     `
-fn volumetrics_froxel_coord_to_uvw(
+fn volumetrics_froxel_coord_to_frustum_uvw(
     coord: vec3<u32>,
     res: vec3<u32>,
     camera: ${CAMERA_UNIFORM_STRUCT.wgsl_ref},
@@ -139,7 +152,7 @@ fn world_pos_from_froxel(
     cluster_params: vec3f,
     frustum: array<vec4<f32>, 6>
 ) -> vec3f {
-    let uvw = volumetrics_froxel_coord_to_uvw(coord, res, camera, cluster_params);
+    let uvw = volumetrics_froxel_coord_to_frustum_uvw(coord, res, camera, cluster_params);
 
     // Reconstruct the froxel-centre world position. frustum_sample_point intersects the
     // interpolated L/R, B/T, N/F planes; X maps left->left and Z maps near->far directly, so only
@@ -150,7 +163,7 @@ fn world_pos_from_froxel(
     return frustum_sample_point(frustum, vec3f(uvw.x, 1.0 - uvw.y, uvw.z));
 }
 `, [
-        chunk_volumetrics_froxel_coord_to_uvw,
+        chunk_volumetrics_froxel_coord_to_frustum_uvw,
         chunk_frustum_sample_point,
     ]);
 
@@ -312,8 +325,6 @@ fn main(@builtin(global_invocation_id) voxel_id: vec3<u32>) {
         chunk_ndc_to_uv,
         chunk_volumetric_history_bounding_box,
         chunk_aabb4_normalized_dist,
-        chunk_volumetrics_froxel_coord_to_uvw,
-        chunk_frustum_sample_point,
     ]
 );