@woosh/meep-engine 3.14.6 → 3.16.0

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_build_warp.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Per-frame inputs of the warp build, all of which land in the warp header.
+ */
+export const AVBOIT_BUILD_WARP_SETTINGS_STRUCT: WebGPUStruct;
+export const shader_avboit_build_warp: ComputeShader;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_avboit_build_warp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_avboit_build_warp.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_build_warp.js"],"names":[],"mappings":"AAWA;;GAEG;AACH,6DAUqC;AA0GrC,qDAIG;6BApI0B,sCAAsC;8BAErC,kCAAkC"}

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

@@ -0,0 +1,135 @@
+import { u32, vec3f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { AVBOIT_OCCUPANCY_WORDS, AVBOIT_VIRTUAL_SLICES_MAX } from "./AVBOIT_CONSTANTS.js";
+import { AVBOIT_WARP_STRUCT } from "./AVBOIT_WARP_STRUCT.js";
+import { chunk_avboit_dilate_word } from "./chunk_avboit_dilate_word.js";
+import { chunk_avboit_fold_pairs } from "./chunk_avboit_fold_pairs.js";
+
+/**
+ * Per-frame inputs of the warp build, all of which land in the warp header.
+ */
+export const AVBOIT_BUILD_WARP_SETTINGS_STRUCT = WebGPUStruct.from({
+    /** AVBOIT_PHYSICAL_SLICES */
+    physical_count: u32,
+    /** extinction volume XY resolution, copied into the warp header for the fragment shaders */
+    voxel_width: u32,
+    voxel_height: u32,
+    /** AVBOITSettings.transmission_tint_from_base_color as 0 / 1, copied into the header */
+    tint_from_base_color: u32,
+    /** the depth curve, see avboit_build_depth_curve */
+    cluster_parameters: vec3f,
+}, "AVBOITBuildWarpSettings").pack();
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform("settings", AVBOIT_BUILD_WARP_SETTINGS_STRUCT)
+    .addStorageBuffer("occupancy", WebGPUArray.from(u32, AVBOIT_OCCUPANCY_WORDS))
+    .addStorageBuffer("warp", AVBOIT_WARP_STRUCT, true)
+;
+
+/**
+ * AVBOIT warp build: turns the finest-level occupancy bits into the depth-warp LUT (plan §3.4).
+ *
+ * One invocation does the whole thing. Per level: dilate by one slice each side at that level,
+ * count; if the count fits the physical budget, or the level is already down at the physical count,
+ * stop — otherwise halve the *undilated* bits by OR-ing adjacent pairs and go again. Dilation is
+ * applied fresh at each level rather than once at the finest, because a one-slice margin at 1024
+ * slices is a quarter of a slice at 256 and rounds away; the margin is what keeps a fragment on the
+ * edge of a meshlet's bounds from linear-splatting into a neighbouring run.
+ *
+ * The LUT is then an exclusive prefix count of the dilated bits, with the bit itself in the low
+ * position — see `AVBOIT_WARP_STRUCT`.
+ *
+ * Single-lane by design, not as a fallback: 32 words and at most three halvings is a few thousand
+ * bit operations, and staying single-lane is what lets the WGSL emulator run this shader as-is.
+ */
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const AVBOIT_OCCUPANCY_WORDS: u32 = ${AVBOIT_OCCUPANCY_WORDS}u;
+
+@compute @workgroup_size(1)
+fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+
+    if (global_id.x != 0u) {
+        return;
+    }
+
+    let physical = settings.physical_count;
+
+    var words: array<u32, AVBOIT_OCCUPANCY_WORDS>;
+    var dilated: array<u32, AVBOIT_OCCUPANCY_WORDS>;
+
+    for (var w = 0u; w < AVBOIT_OCCUPANCY_WORDS; w++) {
+        words[w] = occupancy[w];
+        dilated[w] = 0u;
+    }
+
+    var level_count = ${AVBOIT_VIRTUAL_SLICES_MAX}u;
+    var word_count = AVBOIT_OCCUPANCY_WORDS;
+
+    loop {
+        var occupied = 0u;
+
+        for (var w = 0u; w < word_count; w++) {
+            var below = 0u;
+            if (w > 0u) {
+                below = words[w - 1u] >> 31u;
+            }
+            var above = 0u;
+            if (w + 1u < word_count) {
+                above = (words[w + 1u] & 1u) << 31u;
+            }
+            let d = avboit_dilate_word(words[w], below, above);
+            dilated[w] = d;
+            occupied += countOneBits(d);
+        }
+
+        if (occupied <= physical || level_count <= physical) {
+            break;
+        }
+
+        // halve: two old words become one new word
+        let half_words = word_count / 2u;
+        for (var nw = 0u; nw < half_words; nw++) {
+            words[nw] = avboit_fold_pairs(words[2u * nw]) | (avboit_fold_pairs(words[2u * nw + 1u]) << 16u);
+        }
+
+        word_count = half_words;
+        level_count = level_count / 2u;
+    }
+
+    warp.virtual_count = level_count;
+    warp.physical_count = physical;
+    warp.voxel_width = settings.voxel_width;
+    warp.voxel_height = settings.voxel_height;
+    warp.tint_from_base_color = settings.tint_from_base_color;
+    warp.cluster_parameters = settings.cluster_parameters;
+
+    var prefix = 0u;
+
+    for (var v = 0u; v < level_count; v++) {
+        let bit = (dilated[v >> 5u] >> (v & 31u)) & 1u;
+        warp.lut[v] = (prefix << 1u) | bit;
+        prefix += bit;
+    }
+
+    warp.lut[level_count] = prefix << 1u;
+    warp.occupied_count = prefix;
+}
+    `, [
+        chunk_avboit_dilate_word,
+        chunk_avboit_fold_pairs,
+    ]
+);
+
+export const shader_avboit_build_warp = ComputeShader.from({
+    label: 'AVBOIT / build warp',
+    resources,
+    body,
+});

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_draw_brick4.d.ts

@@ -0,0 +1,3 @@
+export const shader_avboit_draw_brick4: RenderPassDescriptor;
+import { RenderPassDescriptor } from "../../../shader/pass/RenderPassDescriptor.js";
+//# sourceMappingURL=shader_avboit_draw_brick4.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_avboit_draw_brick4.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_draw_brick4.js"],"names":[],"mappings":"AA2FA,6DAAoE;qCAnF/B,8CAA8C"}

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

@@ -0,0 +1,101 @@
+import { RenderPipelineDescriptor } from "../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { CAMERA_UNIFORM_STRUCT } from "../../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { SHADING_LIGHT_RESOURCE_GROUP } from "../../../deferred/SHADING_LIGHT_RESOURCE_GROUP.js";
+import { DEPTH_BACKGROUND_VALUE } from "../../../depth/DEPTH_BACKGROUND_VALUE.js";
+import { BRICK4_DATA_STRUCT } from "../../../global_illumination/brick4/gpu/BRICK4_DATA_STRUCT.js";
+import { SHADING_MATERIAL_RESOURCE_GROUP } from "../../../material/standard/SHADING_MATERIAL_RESOURCE_GROUP.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { RenderPassColorAttachmentDescriptor } from "../../../shader/pass/RenderPassColorAttachmentDescriptor.js";
+import { RenderPassDescriptor } from "../../../shader/pass/RenderPassDescriptor.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
+import { SAMPLER_LINEAR_UPSCALE } from "../../../texture/SAMPLER_LINEAR_UPSCALE.js";
+import { VIEW_UNIFORM_STRUCT } from "../../../view/VIEW_UNIFORM_STRUCT.js";
+import { VOLUMETRICS_METADATA_STRUCT } from "../../../volumetrics/VOLUMETRICS_METADATA_STRUCT.js";
+import {
+    chunk_forward_shade_standard_fragment_brick4
+} from "../../forward/chunk_forward_shade_standard_fragment_brick4.js";
+import { SHADING_SCENE_RESOURCE_GROUP } from "../../forward/SHADING_SCENE_RESOURCE_GROUP.js";
+import { vertex_shader_chunk } from "../../forward/vertex_shader_chunk.js";
+import { rasterization_primitive_state } from "../rasterization_primitive_state.js";
+import { AVBOIT_WARP_STRUCT } from "./AVBOIT_WARP_STRUCT.js";
+import {
+    AVBOIT_DRAW_FRAGMENT_BODY,
+    AVBOIT_DRAW_FRAGMENT_DEPENDENCIES,
+    AVBOIT_DRAW_TARGETS
+} from "./avboit_draw_fragment_body.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.addGroup(SHADING_MATERIAL_RESOURCE_GROUP);
+resources.addGroup(SHADING_SCENE_RESOURCE_GROUP);
+
+// Order is load-bearing: the orchestrator's view bind group lists its entries in this sequence.
+// Identical to the IBL variant except for the brick4 buffer after the integral sampler.
+resources.createGroup()
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("view", VIEW_UNIFORM_STRUCT)
+    .addStorageBuffer("warp", AVBOIT_WARP_STRUCT)
+    // sampled through sLinear below: linear, clamped on every axis, which is what the integral needs
+    .addTexture("tIntegral", "float", "3d")
+    .addStorageBuffer("brick4", BRICK4_DATA_STRUCT, false)
+    .addTexture("tSplitSum", "float")
+    .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
+    // volumetrics (composited inline)
+    .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
+    .addTexture("tVolumetrics", "float", "3d")
+    .addTexture("tSTBN_vec3", "float", "3d")
+
+resources.addGroup(SHADING_LIGHT_RESOURCE_GROUP);
+
+const shader_vertex = ShaderDescriptor.from({
+    label: 'AVBOIT Brick4 / vertex shader',
+    body: vertex_shader_chunk,
+    resources,
+});
+
+/**
+ * AVBOIT draw, Brick4 (sparse volumetric lightmap) indirect lighting. See `avboit_draw_fragment_body.js`.
+ */
+const shader_fragment = ShaderDescriptor.from({
+    label: "AVBOIT Brick4 / draw",
+    resources,
+    body: CodeChunk.from(AVBOIT_DRAW_FRAGMENT_BODY, [
+        ...AVBOIT_DRAW_FRAGMENT_DEPENDENCIES,
+        chunk_forward_shade_standard_fragment_brick4,
+    ])
+});
+
+const pipeline = RenderPipelineDescriptor.from({
+    label: "AVBOIT Brick4 / draw",
+    layout: resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+    vertex: {
+        module: {
+            code: shader_vertex.source
+        }
+    },
+    fragment: {
+        module: {
+            code: shader_fragment.source
+        },
+        targets: AVBOIT_DRAW_TARGETS,
+    },
+    depthStencil: {
+        // reversed Z
+        depthCompare: "greater",
+        format: "depth32float",
+        depthWriteEnabled: false
+    },
+    primitive: rasterization_primitive_state,
+});
+
+export const shader_avboit_draw_brick4 = new RenderPassDescriptor();
+shader_avboit_draw_brick4.pipeline = pipeline;
+shader_avboit_draw_brick4.resources = resources;
+shader_avboit_draw_brick4.colorAttachments = AVBOIT_DRAW_TARGETS.map(() => RenderPassColorAttachmentDescriptor.from({
+    clearValue: [0, 0, 0, 0],
+}));
+/**
+ * Clear depth to 0 for reverse Z technique
+ */
+shader_avboit_draw_brick4.depthStencilAttachment.depthClearValue = DEPTH_BACKGROUND_VALUE;

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_draw_ibl.d.ts

@@ -0,0 +1,3 @@
+export const shader_avboit_draw_ibl: RenderPassDescriptor;
+import { RenderPassDescriptor } from "../../../shader/pass/RenderPassDescriptor.js";
+//# sourceMappingURL=shader_avboit_draw_ibl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_avboit_draw_ibl.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_draw_ibl.js"],"names":[],"mappings":"AAsFA,0DAAiE;qCA/E5B,8CAA8C"}

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

@@ -0,0 +1,96 @@
+import { RenderPipelineDescriptor } from "../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { CAMERA_UNIFORM_STRUCT } from "../../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { SHADING_LIGHT_RESOURCE_GROUP } from "../../../deferred/SHADING_LIGHT_RESOURCE_GROUP.js";
+import { DEPTH_BACKGROUND_VALUE } from "../../../depth/DEPTH_BACKGROUND_VALUE.js";
+import { SHADING_MATERIAL_RESOURCE_GROUP } from "../../../material/standard/SHADING_MATERIAL_RESOURCE_GROUP.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { RenderPassColorAttachmentDescriptor } from "../../../shader/pass/RenderPassColorAttachmentDescriptor.js";
+import { RenderPassDescriptor } from "../../../shader/pass/RenderPassDescriptor.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
+import { SAMPLER_LINEAR_UPSCALE } from "../../../texture/SAMPLER_LINEAR_UPSCALE.js";
+import { VIEW_UNIFORM_STRUCT } from "../../../view/VIEW_UNIFORM_STRUCT.js";
+import { VOLUMETRICS_METADATA_STRUCT } from "../../../volumetrics/VOLUMETRICS_METADATA_STRUCT.js";
+import { chunk_forward_shade_standard_fragment_ibl } from "../../forward/chunk_forward_shade_standard_fragment_ibl.js";
+import { SHADING_SCENE_RESOURCE_GROUP } from "../../forward/SHADING_SCENE_RESOURCE_GROUP.js";
+import { vertex_shader_chunk } from "../../forward/vertex_shader_chunk.js";
+import { rasterization_primitive_state } from "../rasterization_primitive_state.js";
+import { AVBOIT_WARP_STRUCT } from "./AVBOIT_WARP_STRUCT.js";
+import {
+    AVBOIT_DRAW_FRAGMENT_BODY,
+    AVBOIT_DRAW_FRAGMENT_DEPENDENCIES,
+    AVBOIT_DRAW_TARGETS
+} from "./avboit_draw_fragment_body.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.addGroup(SHADING_MATERIAL_RESOURCE_GROUP);
+resources.addGroup(SHADING_SCENE_RESOURCE_GROUP);
+
+// Order is load-bearing: the orchestrator's view bind group lists its entries in this sequence.
+resources.createGroup()
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("view", VIEW_UNIFORM_STRUCT)
+    .addStorageBuffer("warp", AVBOIT_WARP_STRUCT)
+    // sampled through sLinear below: linear, clamped on every axis, which is what the integral needs
+    .addTexture("tIntegral", "float", "3d")
+    .addTexture("tSplitSum", "float")
+    .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
+    // volumetrics (composited inline)
+    .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
+    .addTexture("tVolumetrics", "float", "3d")
+    .addTexture("tSTBN_vec3", "float", "3d")
+
+resources.addGroup(SHADING_LIGHT_RESOURCE_GROUP);
+
+const shader_vertex = ShaderDescriptor.from({
+    label: 'AVBOIT IBL / vertex shader',
+    body: vertex_shader_chunk,
+    resources,
+});
+
+/**
+ * AVBOIT draw, image-based indirect lighting. See `avboit_draw_fragment_body.js`.
+ */
+const shader_fragment = ShaderDescriptor.from({
+    label: "AVBOIT IBL / draw",
+    resources,
+    body: CodeChunk.from(AVBOIT_DRAW_FRAGMENT_BODY, [
+        ...AVBOIT_DRAW_FRAGMENT_DEPENDENCIES,
+        chunk_forward_shade_standard_fragment_ibl,
+    ])
+});
+
+const pipeline = RenderPipelineDescriptor.from({
+    label: "AVBOIT IBL / draw",
+    layout: resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+    vertex: {
+        module: {
+            code: shader_vertex.source
+        }
+    },
+    fragment: {
+        module: {
+            code: shader_fragment.source
+        },
+        targets: AVBOIT_DRAW_TARGETS,
+    },
+    depthStencil: {
+        // reversed Z
+        depthCompare: "greater",
+        format: "depth32float",
+        depthWriteEnabled: false
+    },
+    primitive: rasterization_primitive_state,
+});
+
+export const shader_avboit_draw_ibl = new RenderPassDescriptor();
+shader_avboit_draw_ibl.pipeline = pipeline;
+shader_avboit_draw_ibl.resources = resources;
+shader_avboit_draw_ibl.colorAttachments = AVBOIT_DRAW_TARGETS.map(() => RenderPassColorAttachmentDescriptor.from({
+    clearValue: [0, 0, 0, 0],
+}));
+/**
+ * Clear depth to 0 for reverse Z technique
+ */
+shader_avboit_draw_ibl.depthStencilAttachment.depthClearValue = DEPTH_BACKGROUND_VALUE;

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

@@ -0,0 +1,3 @@
+export const shader_avboit_integrate: ComputeShader;
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_avboit_integrate.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,83 @@
+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,
+});

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_occupancy.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The depth curve, built by `avboit_build_depth_curve`; the same values the warp header carries,
+ * needed here before the header exists.
+ */
+export const AVBOIT_OCCUPANCY_SETTINGS_STRUCT: WebGPUStruct;
+export const shader_avboit_occupancy: ComputeShader;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_avboit_occupancy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_avboit_occupancy.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_occupancy.js"],"names":[],"mappings":"AAmBA;;;GAGG;AACH,4DAEqC;AAyFrC,oDAIG;6BApH0B,sCAAsC;8BAUrC,kCAAkC"}

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

@@ -0,0 +1,119 @@
+import { atomic_u32, u32, vec3f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { CAMERA_UNIFORM_STRUCT } from "../../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_cluster_depth_to_z_slice } from "../../../light/cluster/chunk_cluster_depth_to_z_slice.js";
+import { MESHLET_METADATA_STRUCT } from "../../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
+import { chunk_scene_database_access } from "../../../scene/chunk_scene_database_access.js";
+import { AABB3_STRUCT } from "../../../shader/chunk/geometry/aabb3/AABB3_STRUCT.js";
+import { chunk_aabb3_project } from "../../../shader/chunk/geometry/aabb3/chunk_aabb3_project.js";
+import { chunk_array_to_aabb3 } from "../../../shader/chunk/geometry/aabb3/chunk_array_to_aabb3.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { MESHLET_COLLECTION_STRUCT } from "../../MESHLET_COLLECTION_STRUCT.js";
+import { AVBOIT_OCCUPANCY_WORDS, AVBOIT_VIRTUAL_SLICES_MAX } from "./AVBOIT_CONSTANTS.js";
+import { chunk_avboit_occupancy_range } from "./chunk_avboit_occupancy_range.js";
+import { chunk_avboit_occupancy_word_mask } from "./chunk_avboit_occupancy_word_mask.js";
+
+/**
+ * The depth curve, built by `avboit_build_depth_curve`; the same values the warp header carries,
+ * needed here before the header exists.
+ */
+export const AVBOIT_OCCUPANCY_SETTINGS_STRUCT = WebGPUStruct.from({
+    cluster_parameters: vec3f,
+}, "AVBOITOccupancySettings").pack();
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("settings", AVBOIT_OCCUPANCY_SETTINGS_STRUCT)
+    .addStorageBuffer("scene_database", WebGPUArray.from(u32))
+    .addStorageBuffer("meshlet_metadata", WebGPUArray.from(MESHLET_METADATA_STRUCT))
+;
+
+resources.createGroup()
+    .addStorageBuffer("input", MESHLET_COLLECTION_STRUCT)
+;
+
+resources.createGroup()
+    .addStorageBuffer("occupancy", WebGPUArray.from(atomic_u32, AVBOIT_OCCUPANCY_WORDS), true)
+;
+
+/**
+ * AVBOIT occupancy prepass: one thread per HZB-surviving meshlet, marking the virtual depth slices its
+ * bounds span. The deck voxelizes quads and boxes conservatively in a compute job (slide 75); the
+ * engine already has per-meshlet AABBs on the GPU, which are tighter than a mesh box and free.
+ *
+ * Bounds go local → world → view through `aabb3_project` twice, the same projection the HZB meshlet
+ * filter uses. The camera looks down −Z, so the view-space depth interval is `[-max.z, -min.z]`.
+ * A meshlet entirely in front of the near plane marks nothing; anything else goes through the depth
+ * curve (`cluster_depth_to_z_slice`, clamped to the volume by its own limit) and is dilated one slice
+ * each side (`avboit_occupancy_range`).
+ *
+ * Runs once per transparent bucket (front-sided, double-sided) into the same word array.
+ */
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${COMPUTE_SHADER_DEFAULT_GROUP_SIZE})
+fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+
+    let input_index = global_id.x;
+
+    if (input_index >= input.count) {
+        return;
+    }
+
+    let meshlet = input.elements[input_index];
+
+    let mesh = scene_read_mesh(&scene_database, meshlet.mesh);
+    let node = scene_read_node(&scene_database, mesh.node);
+
+    let local_bounds = array_to_aabb3(meshlet_metadata[meshlet.index].bounds_box);
+    let world_bounds = aabb3_project(local_bounds, node.global);
+    let view_bounds: ${AABB3_STRUCT.wgsl_ref} = aabb3_project(world_bounds, camera.view_matrix);
+
+    // camera looks down -Z: the nearest point of the box has the largest z
+    let depth_min = -view_bounds.max.z;
+    let depth_max = -view_bounds.min.z;
+
+    if (depth_max < camera.clip_near_far.x) {
+        // entirely in front of the near plane
+        return;
+    }
+
+    let limit = ${AVBOIT_VIRTUAL_SLICES_MAX}.0;
+    let slice_near = cluster_depth_to_z_slice(depth_min, settings.cluster_parameters, limit);
+    let slice_far = cluster_depth_to_z_slice(depth_max, settings.cluster_parameters, limit);
+
+    let range = avboit_occupancy_range(slice_near, slice_far);
+
+    let word_first = u32(range.x) >> 5u;
+    let word_last = u32(range.y) >> 5u;
+
+    for (var word = word_first; word <= word_last; word++) {
+        let mask = avboit_occupancy_word_mask(word, range.x, range.y);
+        if (mask != 0u) {
+            atomicOr(&occupancy[word], mask);
+        }
+    }
+}
+    `, [
+        AABB3_STRUCT.declaration_chunk,
+        chunk_array_to_aabb3,
+        chunk_aabb3_project,
+        chunk_scene_database_access,
+        chunk_cluster_depth_to_z_slice,
+        chunk_avboit_occupancy_range,
+        chunk_avboit_occupancy_word_mask,
+    ]
+);
+
+export const shader_avboit_occupancy = ComputeShader.from({
+    label: 'AVBOIT / occupancy',
+    resources,
+    body,
+});

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_resolve.d.ts

@@ -0,0 +1,3 @@
+export const shader_avboit_resolve: ImageShader;
+import { ImageShader } from "../../../shader/ImageShader.js";
+//# sourceMappingURL=shader_avboit_resolve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_avboit_resolve.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_resolve.js"],"names":[],"mappings":"AA4EA,gDAUE;4BApF0B,gCAAgC"}