@woosh/meep-engine 3.15.0 → 3.17.0

package/src/shade/renderer/rasterize/native/avboit/AVBOIT_PLAN_2026_09_03.md

@@ -1,6 +1,6 @@
 # Adaptive voxel-based order-independent transparency (AVBOIT) — implementation plan
 
-**Status:** implemented, default mode, device tier in progress — revision 4
+**Status:** implemented, default mode, device tier in progress — revision 5
 **Date:** 2026-09-03
 **Author:** Alex Goldring / Company Named Limited, with Claude
 **Scope:** `src/shade/renderer/rasterize/native/avboit/` (new), `src/shade/renderer/ShadeTransparencyMode.js`
@@ -26,6 +26,13 @@ Games, SIGGRAPH 2025 (talk deck, 60 pages, `AVBOIT_SIG2025_MDROBOT-final.pdf`)
 > slicing (§3.2) rather than a second one; the bit fold reuses the Morton decode; the integral samples through
 > the sampler the draw already binds; the per-material draw loop is one shared module for both pipelines; and
 > the chunks follow the one-function-per-file convention (§5).
+>
+> **Revision 5** (ledger entry 19) widens the pipeline past meshlets. `AVBOITSideChannel` is a contract for a
+> transparent source that is not a meshlet bucket — the GPU particles are the first — asked for its occupancy,
+> its splat and its draw at the three points where the meshlet buckets contribute theirs (§3.1). The draw grew
+> a fourth accumulator, `emission`, for additive fragments: they cover nothing, so the resolve's
+> renormalization must not scale them (§3.8, §3.9). Integrate and resolve are otherwise untouched, and MBOIT,
+> now the legacy path, gets no channel of its own.
 
 ---
 
@@ -137,6 +144,14 @@ additive and MBOIT ignores them.
 The front and double-sided variants of steps 4 and 6 exist for the same reason as in MBOIT: different
 `cullMode`, so a different pipeline, threaded through `rp_rewrite_for_primitive_state`.
 
+*Revision 5:* steps 2, 4 and 6 also take contributions from **side channels** — transparent sources that are
+not meshlet buckets, the GPU particles being the first. `graph_rasterize_meshes_transparent_avboit` takes
+`side_channels`, an array of `AVBOITSideChannel`, and asks each for its occupancy after the meshlet buckets'
+(step 2), its splat after theirs (step 4) and its draw after theirs (step 6), threading the handles the way
+every pass here does. Steps 5 and 7 are unchanged and cannot tell the two apart. Step 6 writes a fourth
+accumulator, `accum_emission` (§3.9). The orchestrator now returns early only when there are neither
+transparent materials nor channels.
+
 ### 3.2 Depth curve and virtual slices
 
 Let `z` be the fragment's view-space depth (`get_view_space_depth`, positive, world units). *Revision 4:* the
@@ -309,11 +324,19 @@ reads the scene colour as an input and writes a fresh `rgba16float` transient (t
 ```
 T_total = exp(-accum_ext)
 norm    = accum_norm > 1e-4 ? (1 - T_total) / accum_norm : 0
-out     = scene × T_total + accum_color × norm
+out     = scene × T_total + accum_color × norm + accum_emission
 ```
 
 with the same NaN backstop as MBOIT, falling back to the scene colour.
 
+*Revision 5:* `accum_emission` is the fourth accumulator, for fragments that emit without covering —
+additive particles today. Such a fragment writes zero extinction and zero norm, so the normalization, whose
+job is to redistribute exactly the `1 - T_total` the covering surfaces took from the scene, must not touch
+it; it joins the sum as it is, already attenuated by the transmittance in front of it at draw time. The
+alternative, a three-target draw pipeline for frames with no such source, is a variant of the draw the plan
+refuses to keep two of (§5); the cost of the fourth target is one `rgba16float` at internal resolution and a
+`vec4(0)` written by every transparent mesh fragment.
+
 ### 3.10 The switch
 
 `src/shade/renderer/ShadeTransparencyMode.js`:
@@ -390,6 +413,8 @@ src/shade/renderer/rasterize/native/avboit/
     chunk_avboit_integral_depth_coordinate.js   bias, warp, boundary-centred texel coordinate
     chunk_avboit_sample_transmittance.js    trilinear sample and exp
     chunk_avboit_transmission_tint.js       base colour × weight
+    chunk_avboit_splat_slice.js             the two-slice voxel write, shared with the side channels
+    AVBOITSideChannel.js                    the contract for a non-meshlet transparent source (rev 5)
     shader_avboit_occupancy.js              compute, per meshlet
     shader_avboit_build_warp.js             compute, one invocation
     shader_avboit_splat.js                  render pass, 1/8 resolution, atomics

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

@@ -6,17 +6,24 @@
  *
  * Per fragment (plan §3.8): full forward shading and the inline volumetric composite exactly as the
  * MBOIT resolve does them, then the transmittance of everything in front from the integral texture,
- * and three additive outputs:
+ * and four additive outputs:
  *
  * ```
  * color      += shaded × coverage × T            premultiplied, as MBOIT
  * norm       += (1 - T_self) × T                 per channel — the normalization denominator
  * extinction += -log(T_self)                     per channel — the total, resolved to exp(-Σ)
+ * emission   += 0                                light that occludes nothing; a surface has none
  * ```
  *
  * `T_self = (1 - coverage) × tint` is the same self-transmittance the splat recorded for this
  * surface, through the same chunk, which is what keeps the volume and the accumulators consistent.
  *
+ * `emission` is the accumulator for light that is added without covering anything — an additive
+ * particle, a glow. It is already attenuated by `T` when written and joins the resolve as it is,
+ * outside the coverage normalization the other three go through; a surface with coverage writes
+ * nothing to it. It exists so a side channel (`AVBOITSideChannel`) can add light through the same
+ * pass as the surfaces, in the same order-independent way.
+ *
  * The transmittance is sampled *before* shading, and a fragment the volume already calls extinct
  * (`T ≤ 1/256` in every channel) is discarded without being shaded — the per-fragment form of the
  * deck's zero-transmittance early-out, without its depth-buffer rewrite. The bound on what that
@@ -31,7 +38,7 @@ export const AVBOIT_DRAW_FRAGMENT_BODY: string;
  */
 export const AVBOIT_DRAW_FRAGMENT_DEPENDENCIES: CodeChunk[];
 /**
- * The three additive `rgba16float` targets, in `AVBOITDrawOutput` order.
+ * The four additive `rgba16float` targets, in `AVBOITDrawOutput` order.
  * @type {GPUColorTargetState[]}
  */
 export const AVBOIT_DRAW_TARGETS: GPUColorTargetState[];

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

@@ -1 +1 @@
-{"version":3,"file":"avboit_draw_fragment_body.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/avboit_draw_fragment_body.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wCAFU,MAAM,CA8DV;AAEN;;;GAGG;AACH,gDAFU,WAAW,CASnB;AAEF;;;GAGG;AACH,kCAFU,qBAAqB,CAiB3B"}
+{"version":3,"file":"avboit_draw_fragment_body.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/avboit_draw_fragment_body.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wCAFU,MAAM,CAgEV;AAEN;;;GAGG;AACH,gDAFU,WAAW,CASnB;AAEF;;;GAGG;AACH,kCAFU,qBAAqB,CAiB3B"}

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

@@ -15,17 +15,24 @@ import { chunk_avboit_transmission_tint } from "./chunk_avboit_transmission_tint
  *
  * Per fragment (plan §3.8): full forward shading and the inline volumetric composite exactly as the
  * MBOIT resolve does them, then the transmittance of everything in front from the integral texture,
- * and three additive outputs:
+ * and four additive outputs:
  *
  * ```
  * color      += shaded × coverage × T            premultiplied, as MBOIT
  * norm       += (1 - T_self) × T                 per channel — the normalization denominator
  * extinction += -log(T_self)                     per channel — the total, resolved to exp(-Σ)
+ * emission   += 0                                light that occludes nothing; a surface has none
  * ```
  *
  * `T_self = (1 - coverage) × tint` is the same self-transmittance the splat recorded for this
  * surface, through the same chunk, which is what keeps the volume and the accumulators consistent.
  *
+ * `emission` is the accumulator for light that is added without covering anything — an additive
+ * particle, a glow. It is already attenuated by `T` when written and joins the resolve as it is,
+ * outside the coverage normalization the other three go through; a surface with coverage writes
+ * nothing to it. It exists so a side channel (`AVBOITSideChannel`) can add light through the same
+ * pass as the surfaces, in the same order-independent way.
+ *
  * The transmittance is sampled *before* shading, and a fragment the volume already calls extinct
  * (`T ≤ 1/256` in every channel) is discarded without being shaded — the per-fragment form of the
  * deck's zero-transmittance early-out, without its depth-buffer rewrite. The bound on what that
@@ -40,6 +47,7 @@ struct AVBOITDrawOutput {
     @location(0) color : vec4<f32>,
     @location(1) norm : vec4<f32>,
     @location(2) extinction : vec4<f32>,
+    @location(3) emission : vec4<f32>,
 }
 
 @fragment
@@ -90,6 +98,7 @@ fn main(
     out.color = vec4<f32>(color * coverage * transmittance, 0.0);
     out.norm = vec4<f32>((1.0 - self_transmittance) * transmittance, 0.0);
     out.extinction = vec4<f32>(-log(self_transmittance), 0.0);
+    out.emission = vec4<f32>(0.0);
 
     return out;
 }
@@ -109,10 +118,10 @@ export const AVBOIT_DRAW_FRAGMENT_DEPENDENCIES = [
 ];
 
 /**
- * The three additive `rgba16float` targets, in `AVBOITDrawOutput` order.
+ * The four additive `rgba16float` targets, in `AVBOITDrawOutput` order.
  * @type {GPUColorTargetState[]}
  */
-export const AVBOIT_DRAW_TARGETS = ["color", "norm", "extinction"].map(label => ({
+export const AVBOIT_DRAW_TARGETS = ["color", "norm", "extinction", "emission"].map(label => ({
     label,
     format: "rgba16float",
     blend: {

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

@@ -0,0 +1,18 @@
+/**
+ * Add one fragment's share of extinction to one physical slice of the voxel volume (plan §3.5), and
+ * record the slice in the per-channel overflow plane if a field crossed 255 — stored as `P - slice`
+ * under `atomicMax`, so the buffer's zero clear reads as "none" and the nearest overflow wins.
+ *
+ * The enclosing shader binds `warp` (`AVBOIT_WARP_STRUCT`), `extinction_volume` and
+ * `overflow_slice` (`array<atomic<u32>>`, read-write) under those names: this is the splat's write
+ * path, shared by the meshlet splat and every side channel's, so that a particle's extinction lands
+ * in the volume through exactly the code a mesh's does.
+ *
+ * A fragment is spread over two slices by its caller (linear splat, `c = p - 0.5`); this is one of
+ * the two.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_splat_slice: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_splat_slice.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_splat_slice.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_splat_slice.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,uCAFU,SAAS,CAuCjB;0BAzDwB,uCAAuC"}

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

@@ -0,0 +1,58 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_avboit_extinction_to_counts } from "./chunk_avboit_extinction_to_counts.js";
+import { chunk_avboit_overflows } from "./chunk_avboit_overflows.js";
+import { chunk_avboit_pack_counts } from "./chunk_avboit_pack_counts.js";
+
+/**
+ * Add one fragment's share of extinction to one physical slice of the voxel volume (plan §3.5), and
+ * record the slice in the per-channel overflow plane if a field crossed 255 — stored as `P - slice`
+ * under `atomicMax`, so the buffer's zero clear reads as "none" and the nearest overflow wins.
+ *
+ * The enclosing shader binds `warp` (`AVBOIT_WARP_STRUCT`), `extinction_volume` and
+ * `overflow_slice` (`array<atomic<u32>>`, read-write) under those names: this is the splat's write
+ * path, shared by the meshlet splat and every side channel's, so that a particle's extinction lands
+ * in the volume through exactly the code a mesh's does.
+ *
+ * A fragment is spread over two slices by its caller (linear splat, `c = p - 0.5`); this is one of
+ * the two.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_splat_slice = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_splat_slice(column: u32, slice: i32, extinction: vec3<f32>, texel: vec2<u32>) {
+    let physical = i32(warp.physical_count);
+    let s = clamp(slice, 0, physical - 1);
+
+    let counts = avboit_extinction_to_counts(extinction);
+
+    if (all(counts == vec3<u32>(0u))) {
+        return;
+    }
+
+    let previous = atomicAdd(&extinction_volume[column + u32(s)], avboit_pack_counts(counts));
+
+    let overflow = avboit_overflows(previous, counts);
+
+    if (any(overflow)) {
+        let base = (texel.y * warp.voxel_width + texel.x) * 3u;
+        // inverted so that the zero-cleared buffer means "no overflow" and max keeps the nearest
+        let mark = u32(physical - s);
+        if (overflow.x) {
+            atomicMax(&overflow_slice[base], mark);
+        }
+        if (overflow.y) {
+            atomicMax(&overflow_slice[base + 1u], mark);
+        }
+        if (overflow.z) {
+            atomicMax(&overflow_slice[base + 2u], mark);
+        }
+    }
+}
+    `, [
+        chunk_avboit_extinction_to_counts,
+        chunk_avboit_overflows,
+        chunk_avboit_pack_counts,
+    ]
+);

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

@@ -89,6 +89,21 @@ export function graph_avboit_draw({ graph, view_ctx, material_count, materials,
     norm: number;
     extinction: number;
 };
+/**
+ * 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: FramePassBuilder, resolution: ArrayLike<number>): {
+    color: number;
+    norm: number;
+    extinction: number;
+    emission: number;
+};
 /**
  * Adaptive voxel-based order-independent transparency (Drobot, SIGGRAPH 2025). Does not write depth.
  *
@@ -96,6 +111,13 @@ export function graph_avboit_draw({ graph, view_ctx, material_count, materials,
  * 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
@@ -111,7 +133,9 @@ export function graph_avboit_draw({ graph, view_ctx, material_count, materials,
  * @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, avboit, }: FrameGraph): number;
+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, avboit, side_channels, }: FrameGraph): number;
 //# sourceMappingURL=graph_rasterize_meshes_transparent_avboit.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AAgEA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;GAWG;AACH,4JAFa,MAAM,CA4DlB;AAED;;;;;;;;;GASG;AACH,0HAFa,MAAM,CAsDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAkJjE;AAED;;;;;;;;;GASG;AACH,8GAFa,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qUAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAwN7D;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,kTAFa,MAAM,CA4PlB"}
+{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AAgEA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;GAWG;AACH,4JAFa,MAAM,CA4DlB;AAED;;;;;;;;;GASG;AACH,0HAFa,MAAM,CAsDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAkJjE;AAED;;;;;;;;;GASG;AACH,8GAFa,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qUAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAyN7D;AAED;;;;;;;;GAQG;AACH,+EAHW,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAe/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,iUAFa,MAAM,CAqRlB"}

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

@@ -488,6 +488,7 @@ export function graph_avboit_draw({
         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);
@@ -539,7 +540,7 @@ export function graph_avboit_draw({
             : shader_avboit_draw_ibl;
 
         const pass_encoder = encoder.beginRenderPass(render_pass_descriptor.toGPU({
-            colorTargets: [t_color, t_norm, t_extinction],
+            colorTargets: [t_color, t_norm, t_extinction, t_emission],
             depthTarget: t_depth,
             colorLoadOp: data.clear_targets ? "clear" : "load",
             // depth is only tested, never written
@@ -630,16 +631,15 @@ export function graph_avboit_draw({
         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 make = label => pass.create(label, TextureResourceDescriptor.from({
-            resolution: view_ctx.resolution,
-            format: 'rgba16float',
-            usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
-        }));
+        const created = avboit_create_accumulators(pass, view_ctx.resolution);
 
-        pass_data.color = make("AVBOIT accumulated color");
-        pass_data.norm = make("AVBOIT accumulated normalization");
-        pass_data.extinction = make("AVBOIT accumulated extinction");
+        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);
@@ -655,6 +655,31 @@ export function graph_avboit_draw({
         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"),
     };
 }
 
@@ -665,6 +690,13 @@ export function graph_avboit_draw({
  * 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
@@ -680,6 +712,8 @@ export function graph_avboit_draw({
  * @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({
@@ -701,9 +735,11 @@ export function graph_rasterize_meshes_transparent_avboit({
 
                                                               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');
 
@@ -748,7 +784,7 @@ export function graph_rasterize_meshes_transparent_avboit({
         scene_materials.length
     );
 
-    if ((material_count_front + material_count_double) === 0) {
+    if ((material_count_front + material_count_double) === 0 && side_channels.length === 0) {
         // nothing to do
         return color_texture;
     }
@@ -825,6 +861,10 @@ export function graph_rasterize_meshes_transparent_avboit({
         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,
@@ -863,6 +903,10 @@ export function graph_rasterize_meshes_transparent_avboit({
         volume,
     });
 
+    for (const channel of side_channels) {
+        volume = channel.avboit_splat({ graph, camera: gr_camera, warp, depth_texture, voxel_resolution, volume });
+    }
+
     // Integrate
     // ======
 
@@ -916,6 +960,20 @@ export function graph_rasterize_meshes_transparent_avboit({
         ...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
     // ======
 
@@ -928,6 +986,7 @@ export function graph_rasterize_meshes_transparent_avboit({
             tColor: accumulators.color,
             tNorm: accumulators.norm,
             tExtinction: accumulators.extinction,
+            tEmission: accumulators.emission,
         }
     });
 

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

@@ -1 +1 @@
-{"version":3,"file":"shader_avboit_resolve.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_resolve.js"],"names":[],"mappings":"AAsEA,gDAUE;4BA9E0B,gCAAgC"}
+{"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"}

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

@@ -10,18 +10,23 @@ resources.createGroup()
     .addTexture("tColor")
     .addTexture("tNorm")
     .addTexture("tExtinction")
+    .addTexture("tEmission")
 
 /**
- * AVBOIT resolve: composites the three draw accumulators over the scene colour (plan §3.9).
+ * AVBOIT resolve: composites the four draw accumulators over the scene colour (plan §3.9).
  *
  * Per channel:
  *
  * ```
  * T_total = exp(-Σ extinction)
  * norm    = Σ norm > ε ? (1 - T_total) / Σ norm : 0
- * out     = scene × T_total + Σ color × norm
+ * out     = scene × T_total + Σ color × norm + Σ emission
  * ```
  *
+ * `emission` is light the draw already attenuated by the transmittance in front of it and that
+ * covers nothing, so it joins as it is — outside the normalization, which only redistributes the
+ * `1 - T_total` the surfaces took from the scene.
+ *
  * The total transmittance is RGB, which fixed-function blending cannot apply to the destination
  * without dual-source blending, so this reads the scene colour and writes a fresh target rather than
  * blending in place. A NaN in any accumulator drops the transparency for that pixel and keeps the
@@ -42,8 +47,9 @@ fn main(
     let accum_color = textureLoad(tColor, coord_u, 0).rgb;
     let accum_norm = textureLoad(tNorm, coord_u, 0).rgb;
     let accum_extinction = textureLoad(tExtinction, coord_u, 0).rgb;
+    let accum_emission = textureLoad(tEmission, coord_u, 0).rgb;
 
-    if (is_nan(accum_color.r) || is_nan(accum_norm.r) || is_nan(accum_extinction.r)) {
+    if (is_nan(accum_color.r) || is_nan(accum_norm.r) || is_nan(accum_extinction.r) || is_nan(accum_emission.r)) {
         // one NaN fragment poisons the whole pixel of an additive accumulator; keeping the opaque
         // scene beats smearing NaN into the frame
         return scene;
@@ -61,7 +67,7 @@ fn main(
 
     let transparent = accum_color * renormalization;
 
-    return vec4<f32>(scene.rgb * total_transmittance + transparent, scene.a);
+    return vec4<f32>(scene.rgb * total_transmittance + transparent + accum_emission, scene.a);
 }
     `, [
         chunk_is_nan

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

@@ -1 +1 @@
-{"version":3,"file":"shader_avboit_splat.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_splat.js"],"names":[],"mappings":"AA4BA;;;;GAIG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;;GAIG;AACH,yDAAmD;AA6LnD,uDAA8D;qCAzNzB,8CAA8C"}
+{"version":3,"file":"shader_avboit_splat.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_splat.js"],"names":[],"mappings":"AA0BA;;;;GAIG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;;GAIG;AACH,yDAAmD;AA4JnD,uDAA8D;qCAtLzB,8CAA8C"}

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

@@ -19,9 +19,7 @@ import { vertex_shader_chunk } from "../../forward/vertex_shader_chunk.js";
 import { OIT_COVERAGE_MAX } from "../oit/OIT_CONSTANTS.js";
 import { rasterization_primitive_state } from "../rasterization_primitive_state.js";
 import { AVBOIT_WARP_STRUCT } from "./AVBOIT_WARP_STRUCT.js";
-import { chunk_avboit_extinction_to_counts } from "./chunk_avboit_extinction_to_counts.js";
-import { chunk_avboit_overflows } from "./chunk_avboit_overflows.js";
-import { chunk_avboit_pack_counts } from "./chunk_avboit_pack_counts.js";
+import { chunk_avboit_splat_slice } from "./chunk_avboit_splat_slice.js";
 import { chunk_avboit_transmission_tint } from "./chunk_avboit_transmission_tint.js";
 import { chunk_avboit_transmittance_to_extinction } from "./chunk_avboit_transmittance_to_extinction.js";
 import { chunk_avboit_view_depth_to_physical } from "./chunk_avboit_view_depth_to_physical.js";
@@ -74,9 +72,8 @@ const shader_vertex = ShaderDescriptor.from({
  *
  * Depth goes view-space → curve → warp → physical, and the extinction is linear-splat between the
  * two physical slices around it (`c = p - 0.5`) so a surface crossing a slice boundary does not
- * alias. A field that crosses 255 with this add records the slice in the per-channel overflow
- * plane — stored as `P - slice` under `atomicMax`, so the buffer's zero clear reads as "none" and
- * the nearest overflow wins.
+ * alias. The add itself, and the overflow it may record, is `chunk_avboit_splat_slice` — shared
+ * with every side channel's splat, so a particle reaches the volume through the same code.
  *
  * No depth attachment: a splat behind opaque geometry lies deeper than any visible transparent
  * fragment and the integral at a depth only contains what is in front of it. No TAA un-jitter: the
@@ -86,36 +83,6 @@ const shader_vertex = ShaderDescriptor.from({
 const fragment_body = CodeChunk.from(
     //language=WGSL
     `
-fn avboit_splat_slice(column: u32, slice: i32, extinction: vec3<f32>, texel: vec2<u32>) {
-    let physical = i32(warp.physical_count);
-    let s = clamp(slice, 0, physical - 1);
-
-    let counts = avboit_extinction_to_counts(extinction);
-
-    if (all(counts == vec3<u32>(0u))) {
-        return;
-    }
-
-    let previous = atomicAdd(&extinction_volume[column + u32(s)], avboit_pack_counts(counts));
-
-    let overflow = avboit_overflows(previous, counts);
-
-    if (any(overflow)) {
-        let base = (texel.y * warp.voxel_width + texel.x) * 3u;
-        // inverted so that the zero-cleared buffer means "no overflow" and max keeps the nearest
-        let mark = u32(physical - s);
-        if (overflow.x) {
-            atomicMax(&overflow_slice[base], mark);
-        }
-        if (overflow.y) {
-            atomicMax(&overflow_slice[base + 1u], mark);
-        }
-        if (overflow.z) {
-            atomicMax(&overflow_slice[base + 2u], mark);
-        }
-    }
-}
-
 @fragment
 fn main(
     @builtin(front_facing) front_facing : bool,
@@ -174,9 +141,7 @@ fn main(
         chunk_mat4_extract_position,
         chunk_dielectric_specular_color,
         chunk_F_Hauber,
-        chunk_avboit_extinction_to_counts,
-        chunk_avboit_overflows,
-        chunk_avboit_pack_counts,
+        chunk_avboit_splat_slice,
         chunk_avboit_transmission_tint,
         chunk_avboit_transmittance_to_extinction,
         chunk_avboit_view_depth_to_physical,

package/src/shade/renderer/rasterize/standard/graph_rasterize_scene.d.ts

@@ -6,7 +6,12 @@
  * @param {FrameGraph} graph
  * @param {RasterizationJob} job
  * @param {GPUCollectionLimits} limits
- * @returns {number} render buckets buffer resource
+ * @returns {{buckets: number, depth: number, color_targets: number[]}} the render buckets buffer,
+ *   and the depth and colour targets as this pipeline left them
  */
-export function graph_rasterize_scene({ graph, job, limits, }: FrameGraph): number;
+export function graph_rasterize_scene({ graph, job, limits, }: FrameGraph): {
+    buckets: number;
+    depth: number;
+    color_targets: number[];
+};
 //# sourceMappingURL=graph_rasterize_scene.d.ts.map

package/src/shade/renderer/rasterize/standard/graph_rasterize_scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_scene.js"],"names":[],"mappings":"AAcA;;;;;;;;;GASG;AACH,4EAFa,MAAM,CA4LlB"}
+{"version":3,"file":"graph_rasterize_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_scene.js"],"names":[],"mappings":"AAcA;;;;;;;;;;GAUG;AACH,4EAHa;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,EAAE,CAAA;CAAC,CA0MrE"}

package/src/shade/renderer/rasterize/standard/graph_rasterize_scene.js

@@ -20,7 +20,8 @@ import { graph_rasterize_remaining_opaque } from "./graph_rasterize_remaining_op
  * @param {FrameGraph} graph
  * @param {RasterizationJob} job
  * @param {GPUCollectionLimits} limits
- * @returns {number} render buckets buffer resource
+ * @returns {{buckets: number, depth: number, color_targets: number[]}} the render buckets buffer,
+ *   and the depth and colour targets as this pipeline left them
  */
 export function graph_rasterize_scene({
                                           graph,
@@ -207,5 +208,18 @@ export function graph_rasterize_scene({
 
     graph.pop_scope();
 
-    return gr_render_buckets;
+    /*
+     The advanced handles come back with the buckets, mirroring
+     `graph_rasterize_scene_fast_raw`. Returning only the buckets left the caller re-importing the
+     same physical textures to read what this wrote — two ResourceEntry chains for one texture, and
+     no dependency edge at all from the rasterization passes to their consumers. It draws correctly
+     today only because writing an imported resource marks a pass a side-effect, so culling cannot
+     touch it and insertion order saves the picture. Make those targets transient — which
+     `Renderer.js` carries a TODO to do — and the whole opaque chain culls itself with no diagnostic.
+    */
+    return {
+        buckets: gr_render_buckets,
+        depth: gr_texture_depth,
+        color_targets: raster_color_targets,
+    };
 }