@woosh/meep-engine 3.56.0 → 3.57.0

package/src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader.js

@@ -13,6 +13,7 @@ import { chunk_rgb_to_YCoCg } from "../../../shader/chunk/color/YCoCg/chunk_rgb_
 import { chunk_decode_g_buffer_normal } from "../../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
 import { chunk_v3_matrix4_project } from "../../../shader/chunk/geometry/vec3/chunk_v3_matrix4_project.js";
 import { chunk_decode_g_buffer_roughness } from "../../../shader/chunk/material/chunk_decode_g_buffer_roughness.js";
+import { F16_MAX_DEFINITION } from "../../../shader/chunk/math/F16_MAX_DEFINITION.js";
 import { RECIPROCAL_PI_DECLARATION } from "../../../shader/chunk/math/RECIPROCAL_PI_DECLARATION.js";
 import { chunk_murmur3_vec3u } from "../../../shader/chunk/random/murmur/chunk_murmur3_vec3u.js";
 import { chunk_texel_coordinate_to_uv } from "../../../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
@@ -322,7 +323,8 @@ fn main(
 
     // compute variance
     let luma = rgb_to_luminance(result);
-    let variance = max(result_luma_moment2 - luma*luma, 0.0);
+    let raw_variance = result_luma_moment2 - luma*luma;
+    let variance = select(0.0, clamp(raw_variance, 0.0, F16_MAX), raw_variance == raw_variance);
 
     var output: SSRResolveOutput;
     output.radiance = vec4f(color, variance);
@@ -348,6 +350,7 @@ fn main(
         chunk_get_ray_mip_level,
         chunk_project_view_position_from_depth,
         chunk_v3_matrix4_project,
+        F16_MAX_DEFINITION,
         RECIPROCAL_PI_DECLARATION,
         chunk_rgb_to_luminance,
     ]

package/src/shade/renderer/postprocess/ssr/ssr_spatial_denoise_shader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ssr_spatial_denoise_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/ssr_spatial_denoise_shader.js"],"names":[],"mappings":"AA6KA,qDAAuE;AACvE,8DAA+E;AAC/E,0DAAkF;AAClF,mEAA0F;4BArK9D,6BAA6B"}
+{"version":3,"file":"ssr_spatial_denoise_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/ssr_spatial_denoise_shader.js"],"names":[],"mappings":"AA+KA,qDAAuE;AACvE,8DAA+E;AAC/E,0DAAkF;AAClF,mEAA0F;4BAtK9D,6BAA6B"}

package/src/shade/renderer/postprocess/ssr/ssr_spatial_denoise_shader.js

@@ -4,7 +4,8 @@ import { SSR_DENOISE_TILE_SIZE } from "./SSR_DENOISE_TILE_SIZE.js";
 import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
 import { chunk_rgb_to_YCoCg } from "../../shader/chunk/color/YCoCg/chunk_rgb_to_YCoCg.js";
 import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
-import { chunk_safe_sqrt } from "../../shader/chunk/math/chunk_safe_sqrt.js";
+import { chunk_safe_sqrt } from "../../shader/chunk/math/chunk_safe_sqrt.js";
+import { F16_MAX_DEFINITION } from "../../shader/chunk/math/F16_MAX_DEFINITION.js";
 import {
     chunk_texture_channel_gaussian_3x3
 } from "../../shader/chunk/texture/chunk_texture_channel_gaussian_3x3.js";
@@ -134,7 +135,7 @@ ${with_metadata ? `        sum_squared_weights += w_visibility*w_visibility;` :
     
     var out_visibility = sum_color / vec4(vec3(sum_weight), sum_weight * sum_weight);
 ${with_metadata ? `    // Carry bootstrap uncertainty forward so the next passes do not freeze again.
-    out_visibility.w = max(out_visibility.w,bootstrap_variance*sum_squared_weights/(sum_weight*sum_weight));` : ""}
+    out_visibility.w = min(F16_MAX, max(out_visibility.w,bootstrap_variance*sum_squared_weights/(sum_weight*sum_weight)));` : `    out_visibility.w = min(F16_MAX, out_visibility.w);`}
     
 ${with_metadata ? `    var output: SSRResolveOutput;
     output.radiance = out_visibility;
@@ -153,6 +154,7 @@ ${with_metadata ? `    var output: SSRResolveOutput;
             chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight,
             chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight,
             chunk_luma_edge_stopping_weight,
+            F16_MAX_DEFINITION,
             chunk_safe_sqrt,
         ]);
 

package/src/shade/renderer/postprocess/taa/chunk_taa_tonemap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_taa_tonemap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/chunk_taa_tonemap.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;GAaG;AACH,0CAeE;0BArCwB,oCAAoC"}
+{"version":3,"file":"chunk_taa_tonemap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/chunk_taa_tonemap.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,0CAgBE;0BAhCwB,oCAAoC"}

package/src/shade/renderer/postprocess/taa/chunk_taa_tonemap.js

@@ -1,39 +1,35 @@
-import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-
-/**
- * The largest value an `rgba16float` target can hold. A shading result above it stores as `+Inf`.
- * @type {number}
- */
-const HALF_MAX = 65504;
-
-/**
- * Slide 20 of "High Quality Temporal Supersampling" by Brian Karis at SIGGRAPH 2014.
- *
- * The guard on the way in is a FINITE clamp, not just a non-negative one, because the colour target
- * is `rgba16float` and a shading result above its range stores as `+Inf` — a bright emissive, a
- * specular lobe with a small denominator, a light with a large intensity. `rgb / (1 + luma)` is then
- * `Inf / Inf`, which is NaN, and `rgb_to_YCoCg` spreads it across all three channels.
- *
- * That matters here more than it would anywhere else: the result is written to the next frame's
- * history, and the resolve picks the valid-history branch on velocity, occlusion and screen bounds
- * and never on the colour, so `mix(current, NaN, weight)` reproduces the NaN every frame. One frame
- * of overbright shading leaves a pixel no camera motion clears, and a Catmull-Rom tap then spreads
- * it into a blot.
- */
-export const chunk_taa_tonemap = CodeChunk.from(
-    //language=WGSL
-    `
-fn taa_tonemap(rgb: vec3<f32>) -> vec3<f32>{
-    // NaN fails every comparison including with itself, so this is the componentwise "is it a
-    // number" the language gives us; +Inf is brought back to what the target could have held.
-    let finite = select(vec3<f32>(0.0), min(rgb, vec3<f32>(${HALF_MAX}f)), rgb == rgb);
-
-    let luma = rgb_to_luminance(finite);
-
-    return finite / (1 + luma);
-}
-    `, [
-        chunk_rgb_to_luminance
-    ]
-);
+import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
+import { F16_MAX_DEFINITION } from "../../shader/chunk/math/F16_MAX_DEFINITION.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * Slide 20 of "High Quality Temporal Supersampling" by Brian Karis at SIGGRAPH 2014.
+ *
+ * The guard on the way in is a FINITE clamp, not just a non-negative one, because the colour target
+ * is `rgba16float` and a shading result above its range stores as `+Inf` — a bright emissive, a
+ * specular lobe with a small denominator, a light with a large intensity. `rgb / (1 + luma)` is then
+ * `Inf / Inf`, which is NaN, and `rgb_to_YCoCg` spreads it across all three channels.
+ *
+ * That matters here more than it would anywhere else: the result is written to the next frame's
+ * history, and the resolve picks the valid-history branch on velocity, occlusion and screen bounds
+ * and never on the colour, so `mix(current, NaN, weight)` reproduces the NaN every frame. One frame
+ * of overbright shading leaves a pixel no camera motion clears, and a Catmull-Rom tap then spreads
+ * it into a blot.
+ */
+export const chunk_taa_tonemap = CodeChunk.from(
+    //language=WGSL
+    `
+fn taa_tonemap(rgb: vec3<f32>) -> vec3<f32>{
+    // NaN fails every comparison including with itself, so this is the componentwise "is it a
+    // number" the language gives us; +Inf is brought back to what the target could have held.
+    let finite = select(vec3<f32>(0.0), clamp(rgb, vec3<f32>(0.0), vec3<f32>(F16_MAX)), rgb == rgb);
+
+    let luma = rgb_to_luminance(finite);
+
+    return finite / (1 + luma);
+}
+    `, [
+        F16_MAX_DEFINITION,
+        chunk_rgb_to_luminance
+    ]
+);

package/src/shade/renderer/postprocess/taa/chunk_taa_tonemap_inv.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_taa_tonemap_inv.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/chunk_taa_tonemap_inv.js"],"names":[],"mappings":"AAGA;;GAEG;AACH,8CAUE;0BAfwB,oCAAoC"}
+{"version":3,"file":"chunk_taa_tonemap_inv.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/chunk_taa_tonemap_inv.js"],"names":[],"mappings":"AAIA;;GAEG;AACH,8CAYE;0BAjBwB,oCAAoC"}

package/src/shade/renderer/postprocess/taa/chunk_taa_tonemap_inv.js

@@ -1,17 +1,20 @@
-import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-
-/**
- * Slide 20 of "High Quality Temporal Supersampling" by Brian Karis at SIGGRAPH 2014.
- */
-export const chunk_taa_tonemap_inv = CodeChunk.from(
-    //language=WGSL
-    `
-fn taa_tonemap_inv(rgb: vec3<f32>) -> vec3<f32>{
-    let luma = rgb_to_luminance(rgb);
-    return rgb / (1 - luma);
-}
-    `, [
-        chunk_rgb_to_luminance
-    ]
-);
+import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
+import { F16_MAX_DEFINITION } from "../../shader/chunk/math/F16_MAX_DEFINITION.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * Slide 20 of "High Quality Temporal Supersampling" by Brian Karis at SIGGRAPH 2014.
+ */
+export const chunk_taa_tonemap_inv = CodeChunk.from(
+    //language=WGSL
+    `
+fn taa_tonemap_inv(rgb: vec3<f32>) -> vec3<f32>{
+    let safe_rgb = select(vec3<f32>(0.0), max(vec3<f32>(0.0), rgb), rgb == rgb);
+    let luma = rgb_to_luminance(safe_rgb);
+    return min(vec3<f32>(F16_MAX), safe_rgb / max(1.0 - luma, 1.0 / (F16_MAX + 1.0)));
+}
+    `, [
+        F16_MAX_DEFINITION,
+        chunk_rgb_to_luminance
+    ]
+);

package/src/shade/renderer/postprocess/taa/shader_taa.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_taa.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/shader_taa.js"],"names":[],"mappings":"AAuCA,+CAAgD;AAGhD;;;GAGG;AACH,4CAFU,SAAS,CASjB;AAEF;;;;GAIG;AACH,gDAFU,SAAS,CAgBjB;AA6LF,qCAaG;0BA9QuB,oCAAoC;4BAClC,6BAA6B"}
+{"version":3,"file":"shader_taa.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/shader_taa.js"],"names":[],"mappings":"AAwCA,+CAAgD;AAGhD;;;GAGG;AACH,4CAFU,SAAS,CASjB;AAEF;;;;GAIG;AACH,gDAFU,SAAS,CAgBjB;AA+LF,qCAaG;0BAhRuB,oCAAoC;4BAClC,6BAA6B"}

package/src/shade/renderer/postprocess/taa/shader_taa.js

@@ -1,6 +1,7 @@
 import { f32, vec2f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-import { chunk_aabb3_normalized_dist } from "../../shader/chunk/geometry/aabb3/chunk_line_aabb3_clipping_distance.js";
+import { chunk_aabb3_normalized_dist } from "../../shader/chunk/geometry/aabb3/chunk_line_aabb3_clipping_distance.js";
+import { F16_MAX_DEFINITION } from "../../shader/chunk/math/F16_MAX_DEFINITION.js";
 import {
     chunk_texture_sample_catmullrom_hardware_5tap_uv
 } from "../../shader/chunk/texture/sample/chunk_texture_sample_catmullrom_hardware_5tap_uv.js";
@@ -140,11 +141,12 @@ fn main(
         * saturate(settings.history_validity) 
     ) > 1e-5;
      
-    let color_current_raw = max( vec3(0.0), texture_sample_catmullrom_hardware_5tap_uv(
+    let color_current_sample = texture_sample_catmullrom_hardware_5tap_uv(
         ColourTexture,
         sLinear,
         jittered_uv, 
-    ).rgb);
+    ).rgb;
+    let color_current_raw = select(vec3(0.0), clamp(color_current_sample, vec3(0.0), vec3(F16_MAX)), color_current_sample == color_current_sample);
 
     var final_colour:vec4<f32>;
     
@@ -249,6 +251,7 @@ fn main(
     return final_colour.rgba;
 }
 `, [
+        F16_MAX_DEFINITION,
         chunk_taa_decode_color,
         chunk_taa_encode_color,
         chunk_taa_history_color_bounding_box_YCoCg,

package/src/shade/renderer/rasterize/expand/bucket/meshlet/shader_meshlets_extract_bucket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_meshlets_extract_bucket.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/rasterize/expand/bucket/meshlet/shader_meshlets_extract_bucket.js"],"names":[],"mappings":"AA0EA,2DAIG;8BAvE2B,qCAAqC"}
+{"version":3,"file":"shader_meshlets_extract_bucket.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/rasterize/expand/bucket/meshlet/shader_meshlets_extract_bucket.js"],"names":[],"mappings":"AA4EA,2DAIG;8BAzE2B,qCAAqC"}

package/src/shade/renderer/rasterize/expand/bucket/meshlet/shader_meshlets_extract_bucket.js

@@ -42,7 +42,9 @@ fn main(
     
     // clamped to what the output can hold, the way the input read below already is: the header is
     // allowed to over-count, and the count published here is what the expansion downstream reads
-    let bucket_size = min(bucket_data.headers[bucket_id].count, arrayLength(&output.elements));
+    let input_capacity = arrayLength(&bucket_data.elements);
+    let available = select(0u, input_capacity - bucket_start, input_capacity > bucket_start);
+    let bucket_size = min(bucket_data.headers[bucket_id].count, min(available, arrayLength(&output.elements)));
     
     if(thread_id == 0u){
         // copy collection size

package/src/shade/renderer/rasterize/native/avboit/avboit_draw_fragment_body.js

@@ -139,7 +139,7 @@ export const AVBOIT_DRAW_FRAGMENT_DEPENDENCIES = [
  */
 export const AVBOIT_DRAW_TARGETS = ["color", "norm", "extinction", "emission"].map(label => ({
     label,
-    format: "rgba16float",
+    format: "rg11b10ufloat",
     blend: {
         color: {
             operation: "add",

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_splat_slice.js

@@ -29,12 +29,12 @@ fn avboit_splat_counts(column: u32, slice: i32, counts: vec3<u32>, texel: vec2<u
         return;
     }
 
-    let previous = atomicAdd(&extinction_volume[column + u32(s)], avboit_pack_counts(counts));
+    let previous = atomicAdd(&extinction_volume[u32(s) * (warp.voxel_width * warp.voxel_height) + column], avboit_pack_counts(counts));
 
     let overflow = avboit_overflows(previous, counts);
 
     if (any(overflow)) {
-        let base = (texel.y * warp.voxel_width + texel.x) * 3u;
+        let base = column * 3u;
         // inverted so that the zero-cleared buffer means "no overflow" and max keeps the nearest
         let mark = u32(physical - s);
         if (overflow.x) {

package/src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js

@@ -652,7 +652,7 @@ export function graph_avboit_draw({
 export function avboit_create_accumulators(pass, resolution) {
     const make = label => pass.create(label, TextureResourceDescriptor.from({
         resolution,
-        format: 'rgba16float',
+        format: 'rg11b10ufloat',
         usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
     }));
 

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_integrate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_avboit_integrate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_integrate.js"],"names":[],"mappings":"AA8EA,oDAIG;8BA/E2B,kCAAkC"}
+{"version":3,"file":"shader_avboit_integrate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_integrate.js"],"names":[],"mappings":"AAuFA,oDAIG;8BAxF2B,kCAAkC"}

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_integrate.js

@@ -1,83 +1,92 @@
-import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
-import { AVBOIT_INTEGRAL_FORMAT, AVBOIT_INTEGRATE_WORKGROUP_SIZE } from "./AVBOIT_CONSTANTS.js";
-import { AVBOIT_WARP_STRUCT } from "./AVBOIT_WARP_STRUCT.js";
-import { chunk_avboit_counts_to_extinction } from "./chunk_avboit_counts_to_extinction.js";
-import { chunk_avboit_unpack_counts } from "./chunk_avboit_unpack_counts.js";
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.createGroup()
-    .addStorageBuffer("warp", AVBOIT_WARP_STRUCT)
-    .addStorageBuffer("extinction_volume", WebGPUArray.from(u32))
-    .addStorageBuffer("overflow_slice", WebGPUArray.from(u32))
-    .addStorageTexture("integral", AVBOIT_INTEGRAL_FORMAT, "3d", "write-only")
-;
-
-/**
- * AVBOIT integration: one thread per voxel column, summing extinction front to back into the 3D
- * integral texture (plan §3.6).
- *
- * Exclusive prefix: texel `s` holds the integral at the *near boundary* of slice `s`, and the texture
- * has `P + 1` depth texels so that texel `P` holds the total. That convention is what lets a sample
- * that the warp has snapped to a run boundary read exactly the runs in front of it.
- *
- * Per channel, the running value saturates at 1.0 (a transmittance of `1/256`), and from the slice
- * the splat recorded as that channel's first overflow it is pinned there: the packed field may have
- * wrapped past that point and its contents no longer mean anything, but a ray that has overflowed
- * a field is extinct anyway.
- */
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(${AVBOIT_INTEGRATE_WORKGROUP_SIZE}, ${AVBOIT_INTEGRATE_WORKGROUP_SIZE}, 1)
-fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
-
-    let width = warp.voxel_width;
-    let height = warp.voxel_height;
-
-    if (global_id.x >= width || global_id.y >= height) {
-        return;
-    }
-
-    let physical = warp.physical_count;
-    let texel = global_id.y * width + global_id.x;
-    let column = texel * physical;
-    let overflow_base = texel * 3u;
-
-    // first overflow slice per channel; a zero mark means none, which no slice reaches
-    let marks = vec3<u32>(
-        overflow_slice[overflow_base],
-        overflow_slice[overflow_base + 1u],
-        overflow_slice[overflow_base + 2u],
-    );
-    let stop = select(vec3<u32>(physical) - marks, vec3<u32>(physical), marks == vec3<u32>(0u));
-
-    var accumulated = vec3<f32>(0.0);
-
-    for (var s = 0u; s < physical; s++) {
-        textureStore(integral, vec3<i32>(i32(global_id.x), i32(global_id.y), i32(s)), vec4<f32>(accumulated, 1.0));
-
-        let counts = avboit_unpack_counts(extinction_volume[column + s]);
-        let extinction = avboit_counts_to_extinction(counts);
-
-        let pinned = vec3<u32>(s) >= stop;
-        accumulated = select(min(accumulated + extinction, vec3<f32>(1.0)), vec3<f32>(1.0), pinned);
-    }
-
-    textureStore(integral, vec3<i32>(i32(global_id.x), i32(global_id.y), i32(physical)), vec4<f32>(accumulated, 1.0));
-}
-    `, [
-        chunk_avboit_counts_to_extinction,
-        chunk_avboit_unpack_counts,
-    ]
-);
-
-export const shader_avboit_integrate = ComputeShader.from({
-    label: 'AVBOIT / integrate',
-    resources,
-    body,
-});
+import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { AVBOIT_INTEGRAL_FORMAT, AVBOIT_INTEGRATE_WORKGROUP_SIZE } from "./AVBOIT_CONSTANTS.js";
+import { AVBOIT_WARP_STRUCT } from "./AVBOIT_WARP_STRUCT.js";
+import { chunk_avboit_counts_to_extinction } from "./chunk_avboit_counts_to_extinction.js";
+import { chunk_avboit_unpack_counts } from "./chunk_avboit_unpack_counts.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addStorageBuffer("warp", AVBOIT_WARP_STRUCT)
+    .addStorageBuffer("extinction_volume", WebGPUArray.from(u32))
+    .addStorageBuffer("overflow_slice", WebGPUArray.from(u32))
+    .addStorageTexture("integral", AVBOIT_INTEGRAL_FORMAT, "3d", "write-only")
+;
+
+/**
+ * AVBOIT integration: one thread per voxel column, summing extinction front to back into the 3D
+ * integral texture (plan §3.6).
+ *
+ * Exclusive prefix: texel `s` holds the integral at the *near boundary* of slice `s`, and the texture
+ * has `P + 1` depth texels so that texel `P` holds the total. That convention is what lets a sample
+ * that the warp has snapped to a run boundary read exactly the runs in front of it.
+ *
+ * Per channel, the running value saturates at 1.0 (a transmittance of `1/256`), and from the slice
+ * the splat recorded as that channel's first overflow it is pinned there: the packed field may have
+ * wrapped past that point and its contents no longer mean anything, but a ray that has overflowed
+ * a field is extinct anyway.
+ */
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${AVBOIT_INTEGRATE_WORKGROUP_SIZE}, ${AVBOIT_INTEGRATE_WORKGROUP_SIZE}, 1)
+fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+
+    let width = warp.voxel_width;
+    let height = warp.voxel_height;
+
+    if (global_id.x >= width || global_id.y >= height) {
+        return;
+    }
+
+    let physical = warp.physical_count;
+    let plane_stride = width * height;
+    let texel = global_id.y * width + global_id.x;
+    let overflow_base = texel * 3u;
+
+    // first overflow slice per channel; a zero mark means none, which no slice reaches
+    let marks = vec3<u32>(
+        overflow_slice[overflow_base],
+        overflow_slice[overflow_base + 1u],
+        overflow_slice[overflow_base + 2u],
+    );
+    let stop = select(vec3<u32>(physical) - marks, vec3<u32>(physical), marks == vec3<u32>(0u));
+
+    // Linear splat (c = p - 0.5, slice and slice + 1) with p <= occupied_count can touch at most
+    // slices [0, min(occupied_count + 1, physical)).
+    let active_slices = select(0u, min(warp.occupied_count + 1u, physical), warp.occupied_count > 0u);
+
+    var accumulated = vec3<f32>(0.0);
+
+    for (var s = 0u; s < physical; s++) {
+        textureStore(integral, vec3<i32>(i32(global_id.x), i32(global_id.y), i32(s)), vec4<f32>(accumulated, 1.0));
+
+        if (s < active_slices && any(accumulated < vec3<f32>(1.0))) {
+            let pinned = vec3<u32>(s) >= stop;
+            if (all(pinned)) {
+                accumulated = vec3<f32>(1.0);
+            } else {
+                let counts = avboit_unpack_counts(extinction_volume[s * plane_stride + texel]);
+                let extinction = avboit_counts_to_extinction(counts);
+                accumulated = select(min(accumulated + extinction, vec3<f32>(1.0)), vec3<f32>(1.0), pinned);
+            }
+        }
+    }
+
+    textureStore(integral, vec3<i32>(i32(global_id.x), i32(global_id.y), i32(physical)), vec4<f32>(accumulated, 1.0));
+}
+    `, [
+        chunk_avboit_counts_to_extinction,
+        chunk_avboit_unpack_counts,
+    ]
+);
+
+export const shader_avboit_integrate = ComputeShader.from({
+    label: 'AVBOIT / integrate',
+    resources,
+    body,
+});

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_splat.js

@@ -143,7 +143,7 @@ fn main(
     let p = avboit_view_depth_to_physical(&warp, z_view);
 
     let texel = vec2<u32>(vert.position.xy);
-    let column = (texel.y * warp.voxel_width + texel.x) * warp.physical_count;
+    let column = texel.y * warp.voxel_width + texel.x;
 
     // linear splat between the two slices around the fragment
     let c = p - 0.5;

package/src/shade/renderer/shader/ShaderDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShaderDescriptor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ShaderDescriptor.js"],"names":[],"mappings":"AA2EA;IA2OI;;;;;;OAMG;IACH;QAJ4B,KAAK,GAAtB,MAAM;QACgC,SAAS,GAA/C,2BAA2B;QACR,IAAI,EAAvB,SAAS;yBAuBnB;IAhQD;;;OAGG;IACH,oBAEC;IAOD;;;OAGG;IACH,6CAEC;IAOD;;;;;OAKG;IACH,sBAEC;IAQD;;;OAGG;IACH,0CAEC;IAQD;;;OAGG;IACH,qBAQC;IAOD;;;;;OAKG;IACH,oEAMC;IASD;;;;;;;OAOG;IACH,aAHW,eAAe,GACb,gBAAgB,CA8B5B;IAED;;;OAGG;IACH,WAFY,MAAM,CAmCjB;IAED;;;OAGG;IACH,iDA6BC;IAED;;;;;OAKG;IACH,0CAHa,OAAO,CAenB;;CA+BJ;2CA7UY,OAAO,yBAAyB,EAAE,4BAA4B;2BAC9D,OAAO,4BAA4B,EAAE,YAAY;uCACjD,OAAO,wCAAwC,EAAE,wBAAwB;4CAL1C,2CAA2C;0BAF7D,yBAAyB;gCACnB,+BAA+B"}
+{"version":3,"file":"ShaderDescriptor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ShaderDescriptor.js"],"names":[],"mappings":"AA4EA;IAkPI;;;;;;OAMG;IACH;QAJ4B,KAAK,GAAtB,MAAM;QACgC,SAAS,GAA/C,2BAA2B;QACR,IAAI,EAAvB,SAAS;yBAuBnB;IAvQD;;;OAGG;IACH,oBAEC;IAOD;;;OAGG;IACH,6CAEC;IAOD;;;;;OAKG;IACH,sBAEC;IAQD;;;OAGG;IACH,0CAMC;IAQD;;;OAGG;IACH,qBAQC;IAOD;;;;;OAKG;IACH,oEAMC;IASD;;;;;;;OAOG;IACH,aAHW,eAAe,GACb,gBAAgB,CA8B5B;IAED;;;OAGG;IACH,WAFY,MAAM,CAqCjB;IAED;;;OAGG;IACH,iDA6BC;IAED;;;;;OAKG;IACH,0CAHa,OAAO,CAgBnB;;CA+BJ;2CApVY,OAAO,yBAAyB,EAAE,4BAA4B;2BAC9D,OAAO,4BAA4B,EAAE,YAAY;uCACjD,OAAO,wCAAwC,EAAE,wBAAwB;4CAL1C,2CAA2C;0BAF7D,yBAAyB;gCACnB,+BAA+B"}

package/src/shade/renderer/shader/ShaderDescriptor.js

@@ -1,4 +1,5 @@
 import { assert } from "../../../core/assert.js";
+import { wgsl_enable_extension } from "../../descriptor/WebGPUExtensionType.js";
 import { CodeChunk } from "./compiler/CodeChunk.js";
 import { ShaderSwitchSet } from "./compiler/ShaderSwitchSet.js";
 import { ShaderResourceSetDescriptor } from "./resource/ShaderResourceSetDescriptor.js";
@@ -127,6 +128,10 @@ export class ShaderDescriptor {
      * @return {string|GPUFeatureName[]}
      */
     get features() {
+        if (this.#source === undefined) {
+            this.#source = this.compile();
+        }
+
         return this.#features;
     }
 
@@ -232,10 +237,12 @@ export class ShaderDescriptor {
          * @type {string[]}
          */
         const result_parts = [];
-        // Enable extensions
+        // Enable extensions: `compiled.extensions` holds WebGPU `GPUFeatureName`s
+        // (`"shader-f16"`, `"subgroups"`), which `#features` keeps for `validate_gpu_features`,
+        // while WGSL's `enable` directive takes the WGSL enable-extension name (`f16`, `subgroups`).
         const extensions = compiled.extensions;
         for (const extension of extensions) {
-            result_parts.unshift(`enable ${extension};`);
+            result_parts.unshift(`enable ${wgsl_enable_extension(extension)};`);
         }
 
         // Language extensions take `requires`, not `enable`, and are not GPUFeatureNames — so they
@@ -296,9 +303,10 @@ export class ShaderDescriptor {
      */
     validate_gpu_features(device) {
         const features = device.features;
+        const required = this.features;
 
-        for (let i = 0; i < this.#features.length; i++) {
-            const feature = this.#features[i];
+        for (let i = 0; i < required.length; i++) {
+            const feature = required[i];
 
             if (!features.has(feature)) {
                 throw new Error(`GPU feature "${feature}" is not supported by this device`);

package/src/shade/renderer/shader/chunk/bvh/chunk_bvh_query_aabb_cooperative.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_bvh_query_aabb_cooperative.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/bvh/chunk_bvh_query_aabb_cooperative.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,+CAFU,SAAS,CAuMhB;0BA1RuB,6BAA6B"}
+{"version":3,"file":"chunk_bvh_query_aabb_cooperative.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/bvh/chunk_bvh_query_aabb_cooperative.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,+CAFU,SAAS,CA+MhB;0BAlSuB,6BAA6B"}