@woosh/meep-engine 3.11.3 → 3.13.0

package/src/shade/renderer/shadow/sdf/cascade/shader_scene_sdf_debug_viz.js

@@ -1,128 +1,130 @@
-import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
-import { CAMERA_UNIFORM_STRUCT } from "../../../camera/CAMERA_UNIFORM_STRUCT.js";
-import { chunk_lut_turbo } from "../../../shader/chunk/color/lut/chunk_lut_turbo.js";
-import { chunk_lut_viridis } from "../../../shader/chunk/color/lut/chunk_lut_viridis.js";
-import { AABB3_STRUCT } from "../../../shader/chunk/geometry/aabb3/AABB3_STRUCT.js";
-import { chunk_aabb3_distance_to_ray_v2 } from "../../../shader/chunk/geometry/aabb3/chunk_aabb3_distance_to_ray_v2.js";
-import { chunk_mat4_compose_transform } from "../../../shader/chunk/geometry/mat4/chunk_mat4_compose_transform.js";
-import {
-    chunk_build_orthonormal_matrix_n
-} from "../../../shader/chunk/geometry/normal/chunk_build_orthonormal_matrix_n.js";
-import { chunk_camera_ray_from_uv } from "../../../shader/chunk/geometry/ray/chunk_camera_ray_from_uv.js";
-import { chunk_min_v3 } from "../../../shader/chunk/geometry/vec3/chunk_min_v3.js";
-import { chunk_v3_matrix4_project } from "../../../shader/chunk/geometry/vec3/chunk_v3_matrix4_project.js";
-import {
-    chunk_sdf_texture_region_sample_linear_uv, chunk_sdf_texture_region_sample_linear_uv_hardware
-} from "../../../shader/chunk/sdf/chunk_sdf_texture_region_sample_linear_uv.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { ImageShader } from "../../../shader/ImageShader.js";
-import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
-import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
-import { SAMPLER_LINEAR_UPSCALE } from "../../../texture/SAMPLER_LINEAR_UPSCALE.js";
-
-const resources = new ShaderResourceSetDescriptor();
-
-const PUSH_CONSTANTS = WebGPUStruct.from({
-    world_bounds: AABB3_STRUCT
-})
-
-resources.createGroup()
-    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
-    .addUniform("settings", PUSH_CONSTANTS)
-    .addTexture("tSDF", "float", "3d")
-    .addSampler("sLinear","filtering", SAMPLER_LINEAR_UPSCALE)
-;
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@fragment
-fn main(
-    
-    @builtin(position) coord: vec4<f32>,
-    @location(0) uv: vec2<f32>,
-    
-) -> @location(0) vec4<f32>{
-    let ray = camera_ray_from_uv(uv, camera);
-    
-    let bounds = settings.world_bounds;
-    
-    let span = bounds.max - bounds.min;
-    let span_rcp = 1 / span;
-    
-    let sdf_transform = mat4_compose_transform( bounds.min, vec4(0.0, 0.0, 0.0, 1.0), span);
-    let sdf_transform_inverse = mat4_compose_transform(  - bounds.min * span_rcp, vec4(0.0, 0.0, 0.0, 1.0), span_rcp);
-    
-    const MAX_MARCHING_STEPS = 64;
-    
-    let box_intersection = aabb3_distance_to_ray( bounds.min, bounds.max, ray.origin, ray.direction);
-    
-    let sdf_resolution = textureDimensions(tSDF,0);
-    
-    if(box_intersection.y <= 0.0){
-        // no collision with bounding box
-        return vec4(0);
-    }
-    
-    let voxel_bounds = 1.0 / vec3<f32>(sdf_resolution) * span;
-    let voxel_radius = length(voxel_bounds) * 0.7071067811865476;
-    
-    let ray_tbn = build_orthonormal_matrix_n(ray.direction);
-    
-    // Expand SDF to avoid missing surfaces
-    let tolerance = voxel_radius ;
-    
-    // start marchin from the boundary for faster convergence
-    var t = max(box_intersection.x + tolerance + 1e-5, 0.0);
-//    var t =  ray.tmin;
-    
-    var i=0;
-    for (; i < MAX_MARCHING_STEPS; i++) {
-        let local_point = ray.origin + t * ray.direction;
-                
-        let uvw = v3_matrix4_project( local_point, sdf_transform_inverse );
-        
-        if(any(uvw < vec3(0.0)) || any(uvw > vec3(1.0))){
-            // walked outside
-            break;
-        }
-        
-        let dist = textureSampleLevel(tSDF, sLinear, uvw, 0.0).r;
-        
-        if (dist < tolerance) {
-            // got a hit
-            break;
-        }
-        
-        t += abs(dist);
-    }
-    
-    // contract hit ?
-    
-//    return vec4(viridis( saturate((t )*0.03)),1.0);
-    
-    return vec4(turbo( saturate(f32(i) / f32(MAX_MARCHING_STEPS)) ), 1.0);
-}
-    `,
-    [
-        chunk_camera_ray_from_uv,
-        chunk_v3_matrix4_project,
-        chunk_mat4_compose_transform,
-        chunk_aabb3_distance_to_ray_v2,
-        chunk_lut_turbo,
-        chunk_lut_viridis,
-        chunk_min_v3,
-        chunk_build_orthonormal_matrix_n,
-    ]
-);
-
-export const shader_scene_sdf_debug_viz = ImageShader.from({
-    descriptor: ShaderDescriptor.from({
-        label: "Scene SDF Debug Viz",
-        resources,
-        body
-    }),
-    targets: [
-        { format: "rgba8unorm" }
-    ]
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { CAMERA_UNIFORM_STRUCT } from "../../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_lut_turbo } from "../../../shader/chunk/color/lut/chunk_lut_turbo.js";
+import { chunk_lut_viridis } from "../../../shader/chunk/color/lut/chunk_lut_viridis.js";
+import { AABB3_STRUCT } from "../../../shader/chunk/geometry/aabb3/AABB3_STRUCT.js";
+import { chunk_aabb3_distance_to_ray_v2 } from "../../../shader/chunk/geometry/aabb3/chunk_aabb3_distance_to_ray_v2.js";
+import { chunk_mat4_compose_transform } from "../../../shader/chunk/geometry/mat4/chunk_mat4_compose_transform.js";
+import {
+    chunk_build_orthonormal_matrix_n
+} from "../../../shader/chunk/geometry/normal/chunk_build_orthonormal_matrix_n.js";
+import { chunk_camera_ray_from_uv } from "../../../shader/chunk/geometry/ray/chunk_camera_ray_from_uv.js";
+import { chunk_min_v3 } from "../../../shader/chunk/geometry/vec3/chunk_min_v3.js";
+import { chunk_v3_matrix4_project } from "../../../shader/chunk/geometry/vec3/chunk_v3_matrix4_project.js";
+import {
+    chunk_sdf_texture_region_sample_linear_uv, chunk_sdf_texture_region_sample_linear_uv_hardware
+} from "../../../shader/chunk/sdf/chunk_sdf_texture_region_sample_linear_uv.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../../../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
+import { SAMPLER_LINEAR_UPSCALE } from "../../../texture/SAMPLER_LINEAR_UPSCALE.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+const PUSH_CONSTANTS = WebGPUStruct.from({
+    world_bounds: AABB3_STRUCT
+})
+
+
+// per-draw, 32 bytes, read-only: immediate data rather than a uniform buffer. camera stays bound.
+resources.setImmediate("settings", PUSH_CONSTANTS);
+resources.createGroup()
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addTexture("tSDF", "float", "3d")
+    .addSampler("sLinear","filtering", SAMPLER_LINEAR_UPSCALE)
+;
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@fragment
+fn main(
+    
+    @builtin(position) coord: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+    
+) -> @location(0) vec4<f32>{
+    let ray = camera_ray_from_uv(uv, camera);
+    
+    let bounds = settings.world_bounds;
+    
+    let span = bounds.max - bounds.min;
+    let span_rcp = 1 / span;
+    
+    let sdf_transform = mat4_compose_transform( bounds.min, vec4(0.0, 0.0, 0.0, 1.0), span);
+    let sdf_transform_inverse = mat4_compose_transform(  - bounds.min * span_rcp, vec4(0.0, 0.0, 0.0, 1.0), span_rcp);
+    
+    const MAX_MARCHING_STEPS = 64;
+    
+    let box_intersection = aabb3_distance_to_ray( bounds.min, bounds.max, ray.origin, ray.direction);
+    
+    let sdf_resolution = textureDimensions(tSDF,0);
+    
+    if(box_intersection.y <= 0.0){
+        // no collision with bounding box
+        return vec4(0);
+    }
+    
+    let voxel_bounds = 1.0 / vec3<f32>(sdf_resolution) * span;
+    let voxel_radius = length(voxel_bounds) * 0.7071067811865476;
+    
+    let ray_tbn = build_orthonormal_matrix_n(ray.direction);
+    
+    // Expand SDF to avoid missing surfaces
+    let tolerance = voxel_radius ;
+    
+    // start marchin from the boundary for faster convergence
+    var t = max(box_intersection.x + tolerance + 1e-5, 0.0);
+//    var t =  ray.tmin;
+    
+    var i=0;
+    for (; i < MAX_MARCHING_STEPS; i++) {
+        let local_point = ray.origin + t * ray.direction;
+                
+        let uvw = v3_matrix4_project( local_point, sdf_transform_inverse );
+        
+        if(any(uvw < vec3(0.0)) || any(uvw > vec3(1.0))){
+            // walked outside
+            break;
+        }
+        
+        let dist = textureSampleLevel(tSDF, sLinear, uvw, 0.0).r;
+        
+        if (dist < tolerance) {
+            // got a hit
+            break;
+        }
+        
+        t += abs(dist);
+    }
+    
+    // contract hit ?
+    
+//    return vec4(viridis( saturate((t )*0.03)),1.0);
+    
+    return vec4(turbo( saturate(f32(i) / f32(MAX_MARCHING_STEPS)) ), 1.0);
+}
+    `,
+    [
+        chunk_camera_ray_from_uv,
+        chunk_v3_matrix4_project,
+        chunk_mat4_compose_transform,
+        chunk_aabb3_distance_to_ray_v2,
+        chunk_lut_turbo,
+        chunk_lut_viridis,
+        chunk_min_v3,
+        chunk_build_orthonormal_matrix_n,
+    ]
+);
+
+export const shader_scene_sdf_debug_viz = ImageShader.from({
+    descriptor: ShaderDescriptor.from({
+        label: "Scene SDF Debug Viz",
+        resources,
+        body
+    }),
+    targets: [
+        { format: "rgba8unorm" }
+    ]
 });

package/src/shade/renderer/shadow/sdf/graph_draw_sdf_shadows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_draw_sdf_shadows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/sdf/graph_draw_sdf_shadows.js"],"names":[],"mappings":"AA0GA;;;;;;;;GAQG;AACH,kHAFa,MAAM,CAgGlB"}
+{"version":3,"file":"graph_draw_sdf_shadows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/sdf/graph_draw_sdf_shadows.js"],"names":[],"mappings":"AA4GA;;;;;;;;GAQG;AACH,kHAFa,MAAM,CAgGlB"}

package/src/shade/renderer/shadow/sdf/graph_draw_sdf_shadows.js

@@ -20,8 +20,10 @@ import { SDF_DRAW_SETTINGS_STRUCT } from "./SDF_DRAW_SETTINGS_STRUCT.js";
 
 
 const resources = new ShaderResourceSetDescriptor();
+
+// per-draw, 32 bytes, read-only: immediate data rather than a uniform buffer. camera stays bound.
+resources.setImmediate("settings", SDF_DRAW_SETTINGS_STRUCT);
 resources.createGroup()
-    .addUniform("settings", SDF_DRAW_SETTINGS_STRUCT)
     .addTexture("texture_sdf", "unfilterable-float", "3d")
     .addTexture("gBufferDepth")
     .addTexture("gBufferNormals", "uint")
@@ -157,11 +159,11 @@ export function graph_draw_sdf_shadows({
          */
         const viz_mesh = resources.get(data.viz_mesh);
 
-        const buffer_settings = encoder.allocateTransientValueBuffer(SDF_DRAW_SETTINGS_STRUCT, {
+        const buffer_settings = {
             sdf_tile_resolution: sdf.tile_resolution,
             sdf_atlas_resolution: sdf.atlas_resolution_in_tiles,
             slice: pingpong(current_time_in_seconds() / 5, 1),
-        }, GPUBufferUsage.UNIFORM);
+        };
 
         shader.draw({
             encoder,

package/src/shade/renderer/texture/virtual/VirtualTextureManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VirtualTextureManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/virtual/VirtualTextureManager.js"],"names":[],"mappings":"AAwGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IA4KI;;;OAGG;IACH,+BAIC;IAvBD;;OAEG;IACH;;;;;;;;;;MAUE;IAYF;;;OAGG;IACH,8BAIC;IAED;;OAEG;IACH,sBAEC;IAED;;OAEG;IACH,kBAEC;IAED;;;OAGG;IACH,8BAIC;IAED;;OAEG;IACH,qCAIC;IAED;;OAEG;IACH,mCAIC;IAED;;OAEG;IACH,6BAIC;IAED;;OAEG;IACH,sCAIC;IAED;;OAEG;IACH,gCAIC;IAED;;;;OAIG;IACH,6DAQC;IA8DD;;;;;;;OAOG;IACH,4CAFa,MAAM,CA6FlB;IAED;;;;;OAKG;IACH,mDA8EC;IA8ED;;;;;;;;;OASG;IACH,wBAFW,WAAW,QAoFrB;IA8KD;;;;;;OAMG;IACH,wBAqBC;IAED;;;OAGG;IACH,eA2GC;IAID;;;;;;;;;;;;OAYG;IACH;QAN4B,KAAK;QACD,IAAI;QACZ,gBAAgB,EAA7B,MAAM;QACO,oBAAoB,EAAjC,MAAM;QACU,wBAAwB;aAgGlD;IAED,gBA8BC;;CACJ;gCAnuC+B,sBAAsB"}
+{"version":3,"file":"VirtualTextureManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/virtual/VirtualTextureManager.js"],"names":[],"mappings":"AAwGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IA4KI;;;OAGG;IACH,+BAIC;IAvBD;;OAEG;IACH;;;;;;;;;;MAUE;IAYF;;;OAGG;IACH,8BAIC;IAED;;OAEG;IACH,sBAEC;IAED;;OAEG;IACH,kBAEC;IAED;;;OAGG;IACH,8BAIC;IAED;;OAEG;IACH,qCAIC;IAED;;OAEG;IACH,mCAIC;IAED;;OAEG;IACH,6BAIC;IAED;;OAEG;IACH,sCAIC;IAED;;OAEG;IACH,gCAIC;IAED;;;;OAIG;IACH,6DAQC;IA8DD;;;;;;;OAOG;IACH,4CAFa,MAAM,CA6FlB;IAED;;;;;OAKG;IACH,mDA8EC;IA8ED;;;;;;;;;OASG;IACH,wBAFW,WAAW,QAoFrB;IA8KD;;;;;;OAMG;IACH,wBAqBC;IAED;;;OAGG;IACH,eA2GC;IAID;;;;;;;;;;;;OAYG;IACH;QAN4B,KAAK;QACD,IAAI;QACZ,gBAAgB,EAA7B,MAAM;QACO,oBAAoB,EAAjC,MAAM;QACU,wBAAwB;aA6FlD;IAED,gBA8BC;;CACJ;gCAhuC+B,sBAAsB"}

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

@@ -5,7 +5,7 @@ import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDe
 import { graph_read_buffer } from "../../buffer/graph_read_buffer.js";
 import { build_vt_material_pipeline_descriptor } from "../../material/standard/fragment_gbuffer_vt.js";
 import { build_chunk_vt_lookup } from "./build_chunk_vt_lookup.js";
-import { build_shader_vt_feedback, VT_FEEDBACK_PARAMS_STRUCT, VT_FEEDBACK_WORKGROUP_SIZE } from "./build_shader_vt_feedback.js";
+import { build_shader_vt_feedback, VT_FEEDBACK_WORKGROUP_SIZE } from "./build_shader_vt_feedback.js";
 import {
     VT_ENTRY_INVALID,
     VT_ENTRY_MIP_MASK,
@@ -1202,10 +1202,7 @@ export class VirtualTextureManager {
                     viz_buffer_triangle: resources.get(data.viz_triangle).obtainView(),
                     viz_buffer_mesh: resources.get(data.viz_mesh).obtainView(),
                     view: view.uniform_buffer.buffer,
-                    vt_params: context.encoder.allocateTransientValueBuffer(
-                        VT_FEEDBACK_PARAMS_STRUCT,
-                        { stride, jitter, mip_bias }
-                    ),
+                    vt_params: { stride, jitter, mip_bias },
                     scene_database: scene_ctx.scene_database_buffer,
                     meshlet_metadata: scene_ctx.geometries.meshlets.buffer_metadata,
                     meshlet_data: scene_ctx.geometries.meshlets.buffer_data,

package/src/shade/renderer/texture/virtual/build_shader_vt_feedback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build_shader_vt_feedback.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/virtual/build_shader_vt_feedback.js"],"names":[],"mappings":"AAkDA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAJ6B,eAAe,EAAjC,SAAS;IACM,aAAa,EAA5B,MAAM;IACJ,aAAa,CAkKzB;AA7MD;;;;;;;;GAQG;AACH,qDAI8B;AAS9B,2CAA4C;0BA9BlB,oCAAoC;8BAChC,+BAA+B;6BAjBhC,mCAAmC"}
+{"version":3,"file":"build_shader_vt_feedback.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/virtual/build_shader_vt_feedback.js"],"names":[],"mappings":"AAkDA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAJ6B,eAAe,EAAjC,SAAS;IACM,aAAa,EAA5B,MAAM;IACJ,aAAa,CAmKzB;AA9MD;;;;;;;;GAQG;AACH,qDAI8B;AAS9B,2CAA4C;0BA9BlB,oCAAoC;8BAChC,+BAA+B;6BAjBhC,mCAAmC"}

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

@@ -73,11 +73,13 @@ export function build_shader_vt_feedback({ chunk_vt_lookup, hash_capacity }) {
 
     const resources = new ShaderResourceSetDescriptor();
 
+    // per-dispatch, 16 bytes, read-only: immediate data rather than a uniform buffer
+    resources.setImmediate("vt_params", VT_FEEDBACK_PARAMS_STRUCT);
+
     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)
@@ -227,6 +229,5 @@ fn main(
         label: 'vt/feedback',
         body,
         resources,
-        group_size: [VT_FEEDBACK_WORKGROUP_SIZE, VT_FEEDBACK_WORKGROUP_SIZE, 1],
     });
 }

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,CA8DjE;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 {
@@ -46,14 +43,12 @@ export function graph_integrate_sky({ graph }) {
 
         const encoder = context.encoder;
 
-        const settings_type = shader_transmittance_lut.descriptor.resources.getResourceByName("settings").buffer_type;
-
-        const settings = encoder.allocateTransientValueBuffer(settings_type, {
+        const settings = {
             steps: 40,
             // taken off the target being drawn into, so the generator cannot be told a size
             // the texture does not have
             resolution: [output.width, output.height],
-        });
+        };
 
         shader_transmittance_lut.draw({
             encoder: encoder,
@@ -144,11 +139,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 +366,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 +533,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,
     ]
 );