@woosh/meep-engine 3.14.6 → 3.16.0

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

@@ -0,0 +1,994 @@
+import { assert } from "../../../../../core/assert.js";
+import { SamplerDescriptor } from "../../../../descriptor/texture/SamplerDescriptor.js";
+import { BufferResourceDescriptor } from "../../../../device/graph/BufferResourceDescriptor.js";
+import { TextureResourceDescriptor } from "../../../../device/graph/TextureResourceDescriptor.js";
+import { rp_rewrite_for_primitive_state } from "../../../../device/pipeline/rp_rewrite_for_primitive_state.js";
+import { BindGroupDescriptor } from "../../../binding/BindGroupDescriptor.js";
+import { SHADING_LIGHT_RESOURCE_GROUP } from "../../../deferred/SHADING_LIGHT_RESOURCE_GROUP.js";
+import { ShadeDrawMode } from "../../../material/ShadeDrawMode.js";
+import { ShadeDrawSide } from "../../../material/ShadeDrawSide.js";
+import { TransparencyMode } from "../../../material/TransparencyMode.js";
+import { ShadeIndirectLightingMode } from "../../../ShadeIndirectLightingMode.js";
+import { graph_compute_pass } from "../../../shader/graph/compute/graph_compute_pass.js";
+import { graph_image_pass } from "../../../shader/graph/graph_image_pass.js";
+import { graph_import_buffer } from "../../../shader/graph/graph_import_buffer.js";
+import { graph_import_texture } from "../../../shader/graph/graph_import_texture.js";
+import {
+    SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR
+} from "../../../shadow/map/SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR.js";
+import { STATIC_GRAPHICS_ENGINE_ASSETS } from "../../../STATIC_GRAPHICS_ENGINE_ASSETS.js";
+import { rasterization_material_bucket } from "../../expand/bucket/chunk_rasterization_material_bucket.js";
+import { construct_primitive_state } from "../../bucket/construct_primitive_state.js";
+import { filter_materials_by_bucket } from "../../bucket/filter_materials_by_bucket.js";
+import {
+    graph_prepare_meshlet_draw_commands_by_material
+} from "../../bucket/prepare_meshlet_draw_commands_by_material.js";
+import { SHADING_SCENE_RESOURCE_GROUP } from "../../forward/SHADING_SCENE_RESOURCE_GROUP.js";
+import {
+    RASTERIZATION_SHADER_BIND_GROUP_SCENE,
+    RASTERIZATION_SHADER_BIND_GROUP_VIEW
+} from "../alpha_tested_pass_resources.js";
+import { material_draw_indirect } from "../material_draw_indirect.js";
+import {
+    AVBOIT_INTEGRAL_FORMAT,
+    AVBOIT_INTEGRATE_WORKGROUP_SIZE,
+    AVBOIT_OCCUPANCY_WORDS,
+    AVBOIT_PHYSICAL_SLICES,
+    AVBOIT_VOXEL_DOWNSCALE
+} from "./AVBOIT_CONSTANTS.js";
+import { avboit_build_depth_curve } from "./avboit_build_depth_curve.js";
+import { AVBOITSettings } from "./AVBOITSettings.js";
+import { AVBOIT_WARP_STRUCT } from "./AVBOIT_WARP_STRUCT.js";
+import { AVBOIT_BUILD_WARP_SETTINGS_STRUCT, shader_avboit_build_warp } from "./shader_avboit_build_warp.js";
+import { shader_avboit_draw_brick4 } from "./shader_avboit_draw_brick4.js";
+import { shader_avboit_draw_ibl } from "./shader_avboit_draw_ibl.js";
+import { shader_avboit_integrate } from "./shader_avboit_integrate.js";
+import { AVBOIT_OCCUPANCY_SETTINGS_STRUCT, shader_avboit_occupancy } from "./shader_avboit_occupancy.js";
+import { shader_avboit_resolve } from "./shader_avboit_resolve.js";
+import {
+    AVBOIT_SPLAT_BIND_GROUP_VOLUME,
+    AVBOIT_SPLAT_DUMMY_FORMAT,
+    shader_avboit_splat
+} from "./shader_avboit_splat.js";
+
+const BIND_GROUP_LAYOUT_SCENE = SHADING_SCENE_RESOURCE_GROUP.generateBindGroupLayoutDescriptor(GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX);
+const BIND_GROUP_LAYOUT_LIGHT = SHADING_LIGHT_RESOURCE_GROUP.generateBindGroupLayoutDescriptor(GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX);
+
+const WARP_BUFFER_SIZE = AVBOIT_WARP_STRUCT.size;
+
+/**
+ * What a caller that passes no settings gets: every switch at its documented default.
+ * @type {AVBOITSettings}
+ */
+const DEFAULT_SETTINGS = new AVBOITSettings();
+
+/**
+ * Extinction volume XY resolution for an internal resolution.
+ *
+ * @param {ArrayLike<number>} resolution
+ * @returns {number[]}
+ */
+export function avboit_voxel_resolution(resolution) {
+    return [
+        Math.max(1, Math.ceil(resolution[0] / AVBOIT_VOXEL_DOWNSCALE)),
+        Math.max(1, Math.ceil(resolution[1] / AVBOIT_VOXEL_DOWNSCALE)),
+    ];
+}
+
+/**
+ * Occupancy prepass over one bucket's HZB-filtered meshlets (plan §3.3).
+ *
+ * @param {FrameGraph} graph
+ * @param {GPUSceneContext} scene
+ * @param {number} camera resource ID
+ * @param {ArrayLike<number>} cluster_parameters the depth curve, see avboit_build_depth_curve
+ * @param {number} meshlet_collection resource ID, `MESHLET_COLLECTION_STRUCT` with its count header
+ * @param {number} meshlet_iterator_command resource ID, indirect dispatch over the collection
+ * @param {number} [occupancy] resource ID of an existing occupancy buffer to add to; created when -1
+ * @returns {number} resource ID of the occupancy bits
+ */
+export function graph_avboit_occupancy({
+                                           graph,
+                                           scene,
+                                           camera,
+                                           cluster_parameters,
+                                           meshlet_collection,
+                                           meshlet_iterator_command,
+                                           occupancy = -1,
+                                       }) {
+
+    assert.isNonNegativeInteger(camera, 'camera');
+    assert.isArrayLike(cluster_parameters, 'cluster_parameters');
+    assert.isNonNegativeInteger(meshlet_collection, 'meshlet_collection');
+    assert.isNonNegativeInteger(meshlet_iterator_command, 'meshlet_iterator_command');
+
+    const settings = { cluster_parameters };
+
+    /**
+     *
+     * @param data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute(data, resources, context) {
+        const encoder = context.encoder;
+
+        shader_avboit_occupancy.dispatchIndirect({
+            encoder,
+            command: resources.get(data.command),
+            bindings: {
+                camera: resources.get(data.camera),
+                settings: encoder.allocateTransientValueBuffer(AVBOIT_OCCUPANCY_SETTINGS_STRUCT, settings, GPUBufferUsage.UNIFORM),
+                scene_database: scene.scene_database_buffer,
+                meshlet_metadata: scene.geometries.meshlets.buffer_metadata,
+                input: resources.get(data.input),
+                occupancy: resources.get(data.occupancy),
+            }
+        });
+    }
+
+    const pass_data = {};
+    const pass = graph.add("AVBOIT/occupancy", pass_data, execute);
+
+    pass_data.camera = pass.read(camera);
+    pass_data.input = pass.read(meshlet_collection);
+    pass_data.command = pass.read(meshlet_iterator_command);
+
+    if (occupancy !== -1) {
+        pass.read(occupancy);
+        pass_data.occupancy = pass.write(occupancy);
+    } else {
+        pass_data.occupancy = pass.create("AVBOIT occupancy", BufferResourceDescriptor.empty(
+            AVBOIT_OCCUPANCY_WORDS * 4,
+            GPUBufferUsage.STORAGE
+        ));
+    }
+
+    return pass_data.occupancy;
+}
+
+/**
+ * The depth-warp LUT from the occupancy bits (plan §3.4).
+ *
+ * @param {FrameGraph} graph
+ * @param {number} occupancy resource ID
+ * @param {number[]} voxel_resolution
+ * @param {ArrayLike<number>} cluster_parameters the depth curve, see avboit_build_depth_curve
+ * @param {AVBOITSettings} [avboit] the renderer's switches, carried into the header
+ * @returns {number} resource ID of the `AVBOIT_WARP_STRUCT` buffer
+ */
+export function graph_avboit_build_warp({
+                                            graph,
+                                            occupancy,
+                                            voxel_resolution,
+                                            cluster_parameters,
+                                            avboit = DEFAULT_SETTINGS,
+                                        }) {
+
+    assert.isNonNegativeInteger(occupancy, 'occupancy');
+    assert.isArrayLike(cluster_parameters, 'cluster_parameters');
+
+    const settings = {
+        physical_count: AVBOIT_PHYSICAL_SLICES,
+        voxel_width: voxel_resolution[0],
+        voxel_height: voxel_resolution[1],
+        tint_from_base_color: avboit.transmission_tint_from_base_color ? 1 : 0,
+        cluster_parameters,
+    };
+
+    /**
+     *
+     * @param data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute(data, resources, context) {
+        const encoder = context.encoder;
+
+        shader_avboit_build_warp.dispatch({
+            encoder,
+            bindings: {
+                // a few words per frame: a transient uniform, serialized from the plain object
+                settings: encoder.allocateTransientValueBuffer(AVBOIT_BUILD_WARP_SETTINGS_STRUCT, settings, GPUBufferUsage.UNIFORM),
+                occupancy: resources.get(data.occupancy),
+                warp: resources.get(data.warp),
+            },
+            group_count_x: 1,
+            group_count_y: 1,
+            group_count_z: 1,
+        });
+    }
+
+    // Recorded by hand rather than through graph_compute_pass: the warp is a read_write storage
+    // buffer, which that helper treats as a managed input and will not create from a descriptor.
+    const pass_data = {};
+    const pass = graph.add("AVBOIT/build warp", pass_data, execute);
+
+    pass_data.occupancy = pass.read(occupancy);
+    // every entry that can be read is written; no clear
+    pass_data.warp = pass.create("AVBOIT warp", BufferResourceDescriptor.from(WARP_BUFFER_SIZE, GPUBufferUsage.STORAGE));
+
+    return pass_data.warp;
+}
+
+/**
+ * Splat one bucket's transparent draws into the extinction volume (plan §3.5).
+ *
+ * @param {FrameGraph} graph
+ * @param {GPUViewContext} view_ctx
+ * @param {number} material_count
+ * @param {ShadeMaterial[]} materials
+ * @param {number} draw_commands resource ID
+ * @param {number} meshlets resource ID
+ * @param {number} camera resource ID
+ * @param {number} warp resource ID
+ * @param {number[]} voxel_resolution
+ * @param {PrimitiveState} primitive
+ * @param {{extinction: number, overflow: number, dummy: number}} [volume] existing resources to add to
+ * @returns {{extinction: number, overflow: number, dummy: number}}
+ */
+export function graph_avboit_splat({
+                                       graph,
+                                       view_ctx,
+                                       material_count,
+                                       materials,
+                                       draw_commands,
+                                       meshlets,
+                                       camera,
+                                       warp,
+                                       voxel_resolution,
+                                       primitive,
+                                       volume,
+                                   }) {
+
+    assert.isNonNegativeInteger(material_count, 'material_count');
+    assert.isNonNegativeInteger(draw_commands, 'draw_commands');
+    assert.isNonNegativeInteger(meshlets, 'meshlets');
+    assert.isNonNegativeInteger(warp, 'warp');
+
+    const scene_ctx = view_ctx.scene;
+
+    /**
+     *
+     * @param data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute(data, resources, context) {
+
+        assert.ok(context.graphics.device.features.has("indirect-first-instance"), '"indirect-first-instance" feature needs to be enabled for non-zero firstInstance values to be used.')
+
+        const command_buffer_draw = resources.get(data.draw_commands);
+        const meshlet_buffer = resources.get(data.meshlets);
+
+        const camera_buffer = resources.get(data.camera);
+        const warp_buffer = resources.get(data.warp);
+        const extinction_buffer = resources.get(data.extinction);
+        const overflow_buffer = resources.get(data.overflow);
+        const t_dummy = resources.get(data.dummy);
+
+        const encoder = context.encoder;
+        const graphics = context.graphics;
+        const bind_manager = graphics.bind_groups;
+
+        const scene_bindings = bind_manager.obtain(BindGroupDescriptor.from(
+            BIND_GROUP_LAYOUT_SCENE,
+            [
+                { buffer: meshlet_buffer },
+                { buffer: scene_ctx.geometries.meshlets.buffer_metadata },
+                { buffer: scene_ctx.geometries.meshlets.buffer_data },
+                { buffer: scene_ctx.scene_database_buffer },
+                { buffer: scene_ctx.geometries.buffer_metadata },
+            ]
+        ));
+
+        const render_pass_descriptor = shader_avboit_splat;
+        const layouts = render_pass_descriptor.pipeline.layout.bindGroupLayouts;
+
+        const view_bindings = bind_manager.obtain(BindGroupDescriptor.from(
+            layouts[RASTERIZATION_SHADER_BIND_GROUP_VIEW],
+            [
+                { buffer: camera_buffer },
+                { buffer: warp_buffer },
+            ]
+        ));
+
+        const volume_bindings = bind_manager.obtain(BindGroupDescriptor.from(
+            layouts[AVBOIT_SPLAT_BIND_GROUP_VOLUME],
+            [
+                { buffer: extinction_buffer },
+                { buffer: overflow_buffer },
+            ]
+        ));
+
+        // the dummy target is never written; it only sizes the raster
+        const pass_encoder = encoder.beginRenderPass(render_pass_descriptor.toGPU({
+            colorTargets: [t_dummy],
+            colorLoadOp: "clear",
+            colorStoreOp: "discard",
+        }));
+
+        const pipeline_descriptor = rp_rewrite_for_primitive_state(render_pass_descriptor.pipeline, primitive);
+        const pipeline = graphics.render_pipelines.obtain(pipeline_descriptor);
+        pass_encoder.setPipeline(pipeline);
+
+        pass_encoder.setBindGroup(RASTERIZATION_SHADER_BIND_GROUP_SCENE, scene_bindings);
+        pass_encoder.setBindGroup(RASTERIZATION_SHADER_BIND_GROUP_VIEW, view_bindings);
+        pass_encoder.setBindGroup(AVBOIT_SPLAT_BIND_GROUP_VOLUME, volume_bindings);
+
+        material_draw_indirect(
+            scene_ctx.materials,
+            material_count,
+            materials,
+            render_pass_descriptor,
+            bind_manager,
+            pass_encoder,
+            command_buffer_draw
+        );
+
+        pass_encoder.end();
+    }
+
+    const pass_data = {};
+    const pass = graph.add("AVBOIT/splat", pass_data, execute);
+
+    pass_data.draw_commands = pass.read(draw_commands);
+    pass_data.meshlets = pass.read(meshlets);
+    pass_data.camera = pass.read(camera);
+    pass_data.warp = pass.read(warp);
+
+    if (volume !== undefined) {
+        pass.read(volume.extinction);
+        pass_data.extinction = pass.write(volume.extinction);
+        pass.read(volume.overflow);
+        pass_data.overflow = pass.write(volume.overflow);
+        pass.read(volume.dummy);
+        pass_data.dummy = pass.write(volume.dummy);
+    } else {
+        const texel_count = voxel_resolution[0] * voxel_resolution[1];
+
+        // one packed u32 per voxel, column-major with the slice fastest; zeroed every frame
+        pass_data.extinction = pass.create("AVBOIT extinction", BufferResourceDescriptor.empty(
+            texel_count * AVBOIT_PHYSICAL_SLICES * 4,
+            GPUBufferUsage.STORAGE
+        ));
+
+        // three inverted first-overflow marks per texel; zero is "none"
+        pass_data.overflow = pass.create("AVBOIT overflow", BufferResourceDescriptor.empty(
+            texel_count * 3 * 4,
+            GPUBufferUsage.STORAGE
+        ));
+
+        pass_data.dummy = pass.create("AVBOIT splat target", TextureResourceDescriptor.from({
+            resolution: voxel_resolution,
+            format: AVBOIT_SPLAT_DUMMY_FORMAT,
+            usage: GPUTextureUsage.RENDER_ATTACHMENT
+        }));
+    }
+
+    return {
+        extinction: pass_data.extinction,
+        overflow: pass_data.overflow,
+        dummy: pass_data.dummy,
+    };
+}
+
+/**
+ * Integrate the extinction volume into the 3D transmittance-integral texture (plan §3.6).
+ *
+ * @param {FrameGraph} graph
+ * @param {number} warp resource ID
+ * @param {number} extinction resource ID
+ * @param {number} overflow resource ID
+ * @param {number[]} voxel_resolution
+ * @returns {number} resource ID of the integral texture, `P + 1` slices deep
+ */
+export function graph_avboit_integrate({
+                                           graph,
+                                           warp,
+                                           extinction,
+                                           overflow,
+                                           voxel_resolution,
+                                       }) {
+
+    assert.isNonNegativeInteger(warp, 'warp');
+    assert.isNonNegativeInteger(extinction, 'extinction');
+    assert.isNonNegativeInteger(overflow, 'overflow');
+
+    const { integral } = graph_compute_pass({
+        graph,
+        shader: shader_avboit_integrate,
+        bindings: {
+            warp,
+            extinction_volume: extinction,
+            overflow_slice: overflow,
+            integral: TextureResourceDescriptor.from({
+                resolution: [voxel_resolution[0], voxel_resolution[1], AVBOIT_PHYSICAL_SLICES + 1],
+                dimension: "3d",
+                format: AVBOIT_INTEGRAL_FORMAT,
+                usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING
+            }),
+        },
+        group_count: [
+            Math.ceil(voxel_resolution[0] / AVBOIT_INTEGRATE_WORKGROUP_SIZE),
+            Math.ceil(voxel_resolution[1] / AVBOIT_INTEGRATE_WORKGROUP_SIZE),
+            1,
+        ],
+    });
+
+    return integral;
+}
+
+/**
+ * Draw one bucket's transparent materials with full shading into the three accumulators (plan §3.8).
+ *
+ * @param {FrameGraph} graph
+ * @param {GPUViewContext} view_ctx
+ * @param {number} material_count
+ * @param {ShadeMaterial[]} materials
+ * @param {number} draw_commands resource ID
+ * @param {number} meshlets resource ID
+ * @param {number} depth_texture resource ID
+ * @param {number} warp resource ID
+ * @param {number} integral resource ID
+ * @param {PrimitiveState} primitive
+ * @param {number} light_cluster_parameters
+ * @param {number} light_cluster_lookup
+ * @param {number} light_cluster_data
+ * @param {number} shadowmap_atlas
+ * @param {number} volumetrics_lut
+ * @param {number} volumetrics_metadata
+ * @param {{color: number, norm: number, extinction: number}} [accumulators] existing targets to add to
+ * @param {ShadeIndirectLightingMode} indirect_lighting_mode
+ * @returns {{color: number, norm: number, extinction: number}}
+ */
+export function graph_avboit_draw({
+                                      graph,
+                                      view_ctx,
+                                      material_count,
+                                      materials,
+                                      draw_commands,
+                                      meshlets,
+                                      depth_texture,
+                                      warp,
+                                      integral,
+                                      primitive,
+                                      light_cluster_parameters,
+                                      light_cluster_lookup,
+                                      light_cluster_data,
+                                      shadowmap_atlas,
+                                      volumetrics_lut,
+                                      volumetrics_metadata,
+                                      accumulators,
+                                      indirect_lighting_mode = ShadeIndirectLightingMode.IBL,
+                                  }) {
+
+    assert.isNonNegativeInteger(material_count, 'material_count');
+    assert.isNonNegativeInteger(draw_commands, 'draw_commands');
+    assert.isNonNegativeInteger(meshlets, 'meshlets');
+    assert.isNonNegativeInteger(warp, 'warp');
+    assert.isNonNegativeInteger(integral, 'integral');
+
+    const scene_ctx = view_ctx.scene;
+
+    /**
+     *
+     * @param data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute(data, resources, context) {
+
+        assert.ok(context.graphics.device.features.has("indirect-first-instance"), '"indirect-first-instance" feature needs to be enabled for non-zero firstInstance values to be used.')
+
+        const command_buffer_draw = resources.get(data.draw_commands);
+        const meshlet_buffer = resources.get(data.meshlets);
+
+        const t_depth = resources.get(data.depth);
+        const t_color = resources.get(data.color);
+        const t_norm = resources.get(data.norm);
+        const t_extinction = resources.get(data.extinction);
+        const t_emission = resources.get(data.emission);
+
+        const warp_buffer = resources.get(data.warp);
+        const t_integral = resources.get(data.integral);
+
+        const light_cluster_parameters = resources.get(data.light_cluster_parameters);
+        const light_cluster_lookup = resources.get(data.light_cluster_lookup);
+        const light_cluster_data = resources.get(data.light_cluster_data);
+
+        const shadowmap_atlas = resources.get(data.shadowmap_atlas);
+
+        const t_volumetrics_lut = resources.get(data.volumetrics_lut);
+        const volumetrics_metadata = resources.get(data.volumetrics_metadata);
+
+        const encoder = context.encoder;
+        const graphics = context.graphics;
+        const bind_manager = graphics.bind_groups;
+
+        const scene_bindings = bind_manager.obtain(BindGroupDescriptor.from(
+            BIND_GROUP_LAYOUT_SCENE,
+            [
+                { buffer: meshlet_buffer },
+                { buffer: scene_ctx.geometries.meshlets.buffer_metadata },
+                { buffer: scene_ctx.geometries.meshlets.buffer_data },
+                { buffer: scene_ctx.scene_database_buffer },
+                { buffer: scene_ctx.geometries.buffer_metadata },
+            ]
+        ));
+
+        const sampler_shadowmap = graphics.samplers.obtain(SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR);
+
+        const light_bindings = bind_manager.obtain(BindGroupDescriptor.from(
+            BIND_GROUP_LAYOUT_LIGHT,
+            [
+                { buffer: view_ctx.scene.lights.buffer_data },
+                view_ctx.scene.lights.environment.obtainView(),
+                //
+                { buffer: light_cluster_parameters },
+                { buffer: light_cluster_lookup },
+                { buffer: light_cluster_data },
+                //
+                shadowmap_atlas.obtainView(),
+                sampler_shadowmap,
+            ]
+        ));
+
+        const use_brick4 = data.indirect_lighting_mode === ShadeIndirectLightingMode.Brick4;
+        const render_pass_descriptor = use_brick4
+            ? shader_avboit_draw_brick4
+            : shader_avboit_draw_ibl;
+
+        const pass_encoder = encoder.beginRenderPass(render_pass_descriptor.toGPU({
+            colorTargets: [t_color, t_norm, t_extinction, t_emission],
+            depthTarget: t_depth,
+            colorLoadOp: data.clear_targets ? "clear" : "load",
+            // depth is only tested, never written
+            depthLoadOp: "load",
+            storeOp: "store",
+        }));
+
+        const pipeline_descriptor = rp_rewrite_for_primitive_state(render_pass_descriptor.pipeline, primitive);
+        const pipeline = graphics.render_pipelines.obtain(pipeline_descriptor);
+        pass_encoder.setPipeline(pipeline);
+
+        pass_encoder.setBindGroup(RASTERIZATION_SHADER_BIND_GROUP_SCENE, scene_bindings);
+        pass_encoder.setBindGroup(3, light_bindings);
+
+        // linear and clamped on every axis: serves the split-sum LUT and the integral texture alike
+        const sampler_linear = graphics.samplers.obtain(SamplerDescriptor.from({
+            magFilter: "linear",
+        }));
+
+        const t_split_sum_lut = graphics.textures.obtain(STATIC_GRAPHICS_ENGINE_ASSETS.split_sum);
+        const stbn_vec3 = graphics.textures.obtain(STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec3);
+
+        // Entry order matches the view group declared in shader_avboit_draw_ibl / _brick4; the
+        // Brick4 variant carries its lightmap buffer right after the integral texture.
+        const view_bind_entries = use_brick4
+            ? [
+                { buffer: view_ctx.camera.buffer.buffer },
+                { buffer: view_ctx.uniform_buffer.buffer },
+                { buffer: warp_buffer },
+                t_integral.obtainView(),
+                { buffer: view_ctx.scene.volumetric_light_map.buffer },
+                t_split_sum_lut.obtainView(),
+                sampler_linear,
+                // volumetrics
+                { buffer: volumetrics_metadata },
+                t_volumetrics_lut.obtainView(),
+                stbn_vec3.obtainView(),
+            ]
+            : [
+                { buffer: view_ctx.camera.buffer.buffer },
+                { buffer: view_ctx.uniform_buffer.buffer },
+                { buffer: warp_buffer },
+                t_integral.obtainView(),
+                t_split_sum_lut.obtainView(),
+                sampler_linear,
+                // volumetrics
+                { buffer: volumetrics_metadata },
+                t_volumetrics_lut.obtainView(),
+                stbn_vec3.obtainView(),
+            ];
+
+        const view_bindings = bind_manager.obtain(BindGroupDescriptor.from(
+            render_pass_descriptor.pipeline.layout.bindGroupLayouts[RASTERIZATION_SHADER_BIND_GROUP_VIEW],
+            view_bind_entries
+        ));
+
+        pass_encoder.setBindGroup(RASTERIZATION_SHADER_BIND_GROUP_VIEW, view_bindings);
+
+        material_draw_indirect(
+            scene_ctx.materials,
+            material_count,
+            materials,
+            render_pass_descriptor,
+            bind_manager,
+            pass_encoder,
+            command_buffer_draw
+        );
+
+        pass_encoder.end();
+    }
+
+    const pass_data = {
+        indirect_lighting_mode,
+        clear_targets: accumulators === undefined,
+    };
+    const pass = graph.add("AVBOIT/draw", pass_data, execute);
+
+    pass_data.draw_commands = pass.read(draw_commands);
+    pass_data.meshlets = pass.read(meshlets);
+    pass_data.depth = pass.read(depth_texture);
+    pass_data.warp = pass.read(warp);
+    pass_data.integral = pass.read(integral);
+
+    if (accumulators !== undefined) {
+        pass.read(accumulators.color);
+        pass_data.color = pass.write(accumulators.color);
+        pass.read(accumulators.norm);
+        pass_data.norm = pass.write(accumulators.norm);
+        pass.read(accumulators.extinction);
+        pass_data.extinction = pass.write(accumulators.extinction);
+        pass.read(accumulators.emission);
+        pass_data.emission = pass.write(accumulators.emission);
+    } else {
+        const created = avboit_create_accumulators(pass, view_ctx.resolution);
+
+        pass_data.color = created.color;
+        pass_data.norm = created.norm;
+        pass_data.extinction = created.extinction;
+        pass_data.emission = created.emission;
+    }
+
+    pass_data.light_cluster_parameters = pass.read(light_cluster_parameters);
+    pass_data.light_cluster_lookup = pass.read(light_cluster_lookup);
+    pass_data.light_cluster_data = pass.read(light_cluster_data);
+
+    pass_data.shadowmap_atlas = pass.read(shadowmap_atlas);
+
+    pass_data.volumetrics_lut = pass.read(volumetrics_lut);
+    pass_data.volumetrics_metadata = pass.read(volumetrics_metadata);
+
+    return {
+        color: pass_data.color,
+        norm: pass_data.norm,
+        extinction: pass_data.extinction,
+        emission: pass_data.emission,
+    };
+}
+
+/**
+ * The four draw accumulators, created by the first pass that writes them — the meshlet draw, or a
+ * side channel's when there are no transparent materials. One place for their format and usage,
+ * so the meshlet draw and a side channel's draw cannot disagree on what they are drawing into.
+ *
+ * @param {FramePassBuilder} pass the pass that first writes them
+ * @param {ArrayLike<number>} resolution internal resolution
+ * @returns {{color: number, norm: number, extinction: number, emission: number}}
+ */
+export function avboit_create_accumulators(pass, resolution) {
+    const make = label => pass.create(label, TextureResourceDescriptor.from({
+        resolution,
+        format: 'rgba16float',
+        usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
+    }));
+
+    return {
+        color: make("AVBOIT accumulated color"),
+        norm: make("AVBOIT accumulated normalization"),
+        extinction: make("AVBOIT accumulated extinction"),
+        emission: make("AVBOIT accumulated emission"),
+    };
+}
+
+/**
+ * Adaptive voxel-based order-independent transparency (Drobot, SIGGRAPH 2025). Does not write depth.
+ *
+ * Same argument object and same return as `graph_rasterize_meshes_transparent_oit`, so `Renderer`
+ * selects between the two with `transparency_mode` alone. The passes it records are listed in
+ * `AVBOIT_PLAN_2026_09_03.md` §3.1.
+ *
+ * Fragments that are not meshlets — particles — join through `side_channels`: each is asked for its
+ * occupancy after the buckets have marked theirs, for its extinction after the buckets have
+ * splatted, and for its draw after the buckets have drawn, in that order, with the handles threaded
+ * through it. See `AVBOITSideChannel`. With side channels the frame runs even when no transparent
+ * material is in the scene; the bucket passes then have nothing to do and the channels' fragments
+ * composite against the opaque scene alone.
+ *
+ * @param {FrameGraph} graph
+ * @param {number} buckets
+ * @param {GPUViewContext} view_ctx
+ * @param {number[]} viewport
+ * @param {number} color_texture resource ID
+ * @param {number} depth_texture resource ID
+ * @param {GPUCollectionLimits} limits
+ * @param {number} light_cluster_parameters
+ * @param {number} light_cluster_lookup
+ * @param {number} light_cluster_data
+ * @param {number} shadowmap_atlas
+ * @param {number} volumetrics_lut
+ * @param {number} volumetrics_metadata
+ * @param {ShadeIndirectLightingMode} indirect_lighting_mode
+ * @param {AVBOITSettings} [avboit] `Renderer.avboit`; the MBOIT orchestrator ignores it
+ * @param {import("./AVBOITSideChannel.js").AVBOITSideChannel[]} [side_channels] non-meshlet
+ *   sources of transparent fragments; the MBOIT orchestrator ignores them
+ * @returns {number} resource ID of the composited color texture
+ */
+export function graph_rasterize_meshes_transparent_avboit({
+                                                              graph,
+                                                              buckets,
+                                                              view_ctx,
+                                                              viewport,
+                                                              depth_texture,
+                                                              color_texture,
+                                                              limits,
+                                                              light_cluster_parameters,
+                                                              light_cluster_lookup,
+                                                              light_cluster_data,
+
+                                                              shadowmap_atlas,
+
+                                                              volumetrics_lut,
+                                                              volumetrics_metadata,
+
+                                                              indirect_lighting_mode = ShadeIndirectLightingMode.IBL,
+                                                              avboit = DEFAULT_SETTINGS,
+                                                              side_channels = [],
+                                                          }) {
+
+    assert.isNonNegativeInteger(buckets, 'buckets');
+    assert.isArray(side_channels, 'side_channels');
+    assert.isNonNegativeInteger(color_texture, 'color_texture');
+    assert.isNonNegativeInteger(depth_texture, 'depth_texture');
+
+    assert.isNonNegativeInteger(light_cluster_parameters, 'light_cluster_parameters');
+    assert.isNonNegativeInteger(light_cluster_lookup, 'light_cluster_lookup');
+    assert.isNonNegativeInteger(light_cluster_data, 'light_cluster_data');
+
+    assert.isNonNegativeInteger(shadowmap_atlas, 'shadowmap_atlas');
+
+    assert.equal(view_ctx.isGPUViewContext, true, 'view_ctx.isGPUViewContext !== true');
+
+    const scene_ctx = view_ctx.scene;
+
+    /**
+     * @type {ShadeMaterial[]}
+     */
+    const materials_front = [];
+    /**
+     * @type {ShadeMaterial[]}
+     */
+    const materials_double = [];
+
+    const scene_materials = scene_ctx.scene.instances.materials;
+
+    // Front-sided and double-sided materials need different pipeline states, so every raster pass
+    // below runs twice. `ShadeDrawSide.Back` is not drawn, the same as under MBOIT (plan §7).
+    const material_count_front = filter_materials_by_bucket(
+        materials_front, 0,
+        TransparencyMode.Transparent,
+        ShadeDrawMode.Triangles,
+        ShadeDrawSide.Front,
+        scene_materials,
+        scene_materials.length
+    );
+
+    const material_count_double = filter_materials_by_bucket(
+        materials_double, 0,
+        TransparencyMode.Transparent,
+        ShadeDrawMode.Triangles,
+        ShadeDrawSide.Double,
+        scene_materials,
+        scene_materials.length
+    );
+
+    if ((material_count_front + material_count_double) === 0 && side_channels.length === 0) {
+        // nothing to do
+        return color_texture;
+    }
+
+    const bucket_index_front = rasterization_material_bucket(
+        TransparencyMode.Transparent, ShadeDrawMode.Triangles, ShadeDrawSide.Front
+    );
+
+    const bucket_index_double = rasterization_material_bucket(
+        TransparencyMode.Transparent, ShadeDrawMode.Triangles, ShadeDrawSide.Double
+    );
+
+    const primitive_front = construct_primitive_state(ShadeDrawMode.Triangles, ShadeDrawSide.Front);
+    const primitive_double = construct_primitive_state(ShadeDrawMode.Triangles, ShadeDrawSide.Double);
+
+    const gr_hzb = graph_import_texture(graph, view_ctx.hierarchical_z_buffer.texture);
+    const gr_camera = graph_import_buffer(graph, view_ctx.camera.buffer.buffer);
+
+    const voxel_resolution = avboit_voxel_resolution(view_ctx.resolution);
+
+    // the depth curve for this camera, shared by the occupancy prepass and, through the warp
+    // header, by every pass after it
+    const camera = view_ctx.camera.camera;
+    const cluster_parameters = avboit_build_depth_curve(camera.near, camera.far);
+
+    // Draw artifacts (shared with MBOIT)
+    // ======
+
+    const prep_front = graph_prepare_meshlet_draw_commands_by_material({
+        graph,
+        materials: materials_front,
+        bucket_id: bucket_index_front,
+        limits,
+        buckets,
+        scene: scene_ctx,
+        camera: gr_camera,
+        hzb: gr_hzb,
+        resolution: [viewport[2], viewport[3]],
+        label: `${view_ctx.label}/AVBOIT-front`,
+    });
+
+    const prep_double = graph_prepare_meshlet_draw_commands_by_material({
+        graph,
+        materials: materials_double,
+        bucket_id: bucket_index_double,
+        limits,
+        buckets,
+        scene: scene_ctx,
+        camera: gr_camera,
+        hzb: gr_hzb,
+        resolution: [viewport[2], viewport[3]],
+        label: `${view_ctx.label}/AVBOIT-double`,
+    });
+
+    // Occupancy and warp
+    // ======
+
+    let occupancy = graph_avboit_occupancy({
+        graph,
+        scene: scene_ctx,
+        camera: gr_camera,
+        cluster_parameters,
+        meshlet_collection: prep_front.meshlet_collection,
+        meshlet_iterator_command: prep_front.meshlet_iterator_command,
+    });
+
+    occupancy = graph_avboit_occupancy({
+        graph,
+        scene: scene_ctx,
+        camera: gr_camera,
+        cluster_parameters,
+        meshlet_collection: prep_double.meshlet_collection,
+        meshlet_iterator_command: prep_double.meshlet_iterator_command,
+        occupancy,
+    });
+
+    for (const channel of side_channels) {
+        occupancy = channel.avboit_occupancy({ graph, camera: gr_camera, cluster_parameters, occupancy });
+    }
+
+    const warp = graph_avboit_build_warp({
+        graph,
+        occupancy,
+        voxel_resolution,
+        cluster_parameters,
+        avboit,
+    });
+
+    // Splat
+    // ======
+
+    let volume = graph_avboit_splat({
+        graph,
+        view_ctx,
+        material_count: material_count_front,
+        materials: materials_front,
+        draw_commands: prep_front.draw_commands,
+        meshlets: prep_front.meshlets,
+        camera: gr_camera,
+        warp,
+        voxel_resolution,
+        primitive: primitive_front,
+    });
+
+    volume = graph_avboit_splat({
+        graph,
+        view_ctx,
+        material_count: material_count_double,
+        materials: materials_double,
+        draw_commands: prep_double.draw_commands,
+        meshlets: prep_double.meshlets,
+        camera: gr_camera,
+        warp,
+        voxel_resolution,
+        primitive: primitive_double,
+        volume,
+    });
+
+    for (const channel of side_channels) {
+        volume = channel.avboit_splat({ graph, camera: gr_camera, warp, depth_texture, voxel_resolution, volume });
+    }
+
+    // Integrate
+    // ======
+
+    const integral = graph_avboit_integrate({
+        graph,
+        warp,
+        extinction: volume.extinction,
+        overflow: volume.overflow,
+        voxel_resolution,
+    });
+
+    // Draw
+    // ======
+
+    const lighting = {
+        light_cluster_parameters,
+        light_cluster_lookup,
+        light_cluster_data,
+        shadowmap_atlas,
+        volumetrics_lut,
+        volumetrics_metadata,
+        indirect_lighting_mode,
+    };
+
+    let accumulators = graph_avboit_draw({
+        graph,
+        view_ctx,
+        material_count: material_count_front,
+        materials: materials_front,
+        draw_commands: prep_front.draw_commands,
+        meshlets: prep_front.meshlets,
+        depth_texture,
+        warp,
+        integral,
+        primitive: primitive_front,
+        ...lighting,
+    });
+
+    accumulators = graph_avboit_draw({
+        graph,
+        view_ctx,
+        material_count: material_count_double,
+        materials: materials_double,
+        draw_commands: prep_double.draw_commands,
+        meshlets: prep_double.meshlets,
+        depth_texture,
+        warp,
+        integral,
+        primitive: primitive_double,
+        accumulators,
+        ...lighting,
+    });
+
+    for (const channel of side_channels) {
+        accumulators = channel.avboit_draw({
+            graph,
+            view_ctx,
+            camera: gr_camera,
+            depth_texture,
+            warp,
+            integral,
+            volumetrics_lut,
+            volumetrics_metadata,
+            accumulators,
+        });
+    }
+
+    // Resolve
+    // ======
+
+    const [composited] = graph_image_pass({
+        graph,
+        shader: shader_avboit_resolve,
+        output_resolution: view_ctx.resolution,
+        inputs: {
+            tScene: color_texture,
+            tColor: accumulators.color,
+            tNorm: accumulators.norm,
+            tExtinction: accumulators.extinction,
+            tEmission: accumulators.emission,
+        }
+    });
+
+    return composited;
+}