@woosh/meep-engine 3.37.0 → 3.39.0

package/src/shade/renderer/path_tracer/shader/media/chunk_medium_volumes.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The volumes' contribution to a medium at one point: absorption and scattering coefficients, RGB,
+ * 1/m.
+ */
+export const MEDIUM_COEFFICIENTS_STRUCT: WebGPUStruct;
+/**
+ * A stretch of a ray over which the set of volumes it is inside does not change: from where the
+ * caller stands to `next`, the volumes' extinction is at most `majorant`, per channel.
+ */
+export const MEDIUM_PIECE_STRUCT: WebGPUStruct;
+/**
+ * The scene's participating-media volumes as the ray passes see them, read from the scene database
+ * the importing shader binds as `scene_database`:
+ *
+ * - `medium_volumes_coefficients_at(position)`: what every volume containing the point adds,
+ *   `density_at * particle_spec.scattering` and `density_at * (extinction - scattering)`.
+ * - `medium_volumes_piece(origin, direction, t, t_max)`: the next distance past `t` at which the ray
+ *   enters or leaves a volume (or `t_max`), and, up to there, the sum of `density * extinction` over
+ *   the volumes the ray is inside — a majorant, as the edge fade never exceeds one. Walking a ray
+ *   piece by piece keeps a long ray past a small dense volume from paying that volume's majorant
+ *   along all of its length.
+ * - `medium_volumes_rest(origin, direction, t, t_max)`: every volume the rest of the ray crosses as
+ *   one piece — their majorants summed, which bound the medium anywhere on it, up to where the last of
+ *   them ends (or `t_max` when none lies ahead). Where a ray would cross too many volumes to take
+ *   them piece by piece, this ends the walk with a valid majorant, at the price of null collisions
+ *   that grow as the square of the volumes it sums, gaps and all.
+ *
+ * Each call walks the volumes' rows, `[0, participating_media_volumes_count)`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_medium_volumes: CodeChunk;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_medium_volumes.d.ts.map

package/src/shade/renderer/path_tracer/shader/media/chunk_medium_volumes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_medium_volumes.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/path_tracer/shader/media/chunk_medium_volumes.js"],"names":[],"mappings":"AAUA;;;GAGG;AACH,sDAGyB;AAEzB;;;GAGG;AACH,+CAGkB;AAElB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,mCAFU,SAAS,CAyFjB;6BAvI2B,sCAAsC;0BACzC,uCAAuC"}

package/src/shade/renderer/path_tracer/shader/media/chunk_medium_volumes.js

@@ -0,0 +1,137 @@
+import { f32, vec3f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import {
+    chunk_participating_media_volume_sample
+} from "../../../volumetrics/chunk_participating_media_volume_sample.js";
+import {
+    chunk_participating_media_volumes_iterate
+} from "../../../volumetrics/chunk_participating_media_volumes_iterate.js";
+
+/**
+ * The volumes' contribution to a medium at one point: absorption and scattering coefficients, RGB,
+ * 1/m.
+ */
+export const MEDIUM_COEFFICIENTS_STRUCT = WebGPUStruct.from({
+    absorption: vec3f,
+    scattering: vec3f,
+}, "MediumCoefficients");
+
+/**
+ * A stretch of a ray over which the set of volumes it is inside does not change: from where the
+ * caller stands to `next`, the volumes' extinction is at most `majorant`, per channel.
+ */
+export const MEDIUM_PIECE_STRUCT = WebGPUStruct.from({
+    majorant: vec3f,
+    next: f32,
+}, "MediumPiece");
+
+/**
+ * The scene's participating-media volumes as the ray passes see them, read from the scene database
+ * the importing shader binds as `scene_database`:
+ *
+ * - `medium_volumes_coefficients_at(position)`: what every volume containing the point adds,
+ *   `density_at * particle_spec.scattering` and `density_at * (extinction - scattering)`.
+ * - `medium_volumes_piece(origin, direction, t, t_max)`: the next distance past `t` at which the ray
+ *   enters or leaves a volume (or `t_max`), and, up to there, the sum of `density * extinction` over
+ *   the volumes the ray is inside — a majorant, as the edge fade never exceeds one. Walking a ray
+ *   piece by piece keeps a long ray past a small dense volume from paying that volume's majorant
+ *   along all of its length.
+ * - `medium_volumes_rest(origin, direction, t, t_max)`: every volume the rest of the ray crosses as
+ *   one piece — their majorants summed, which bound the medium anywhere on it, up to where the last of
+ *   them ends (or `t_max` when none lies ahead). Where a ray would cross too many volumes to take
+ *   them piece by piece, this ends the walk with a valid majorant, at the price of null collisions
+ *   that grow as the square of the volumes it sums, gaps and all.
+ *
+ * Each call walks the volumes' rows, `[0, participating_media_volumes_count)`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_medium_volumes = CodeChunk.from(
+    //language=WGSL
+    `
+fn medium_volumes_coefficients_at(position: vec3<f32>) -> ${MEDIUM_COEFFICIENTS_STRUCT.wgsl_ref} {
+    var absorption = vec3<f32>(0.0);
+    var scattering = vec3<f32>(0.0);
+
+    let volume_count = participating_media_volumes_count(&scene_database);
+
+    for (var v = 0u; v < volume_count; v++) {
+        let volume = participating_media_volume_read(&scene_database, v);
+
+        let density = participating_media_volume_density_at(volume, position);
+
+        if (density <= 0.0) {
+            continue;
+        }
+
+        let spec = volume.particle_spec;
+
+        scattering += density * spec.scattering;
+        absorption += density * max(spec.extinction - spec.scattering, vec3<f32>(0.0));
+    }
+
+    return ${MEDIUM_COEFFICIENTS_STRUCT.wgsl_ref}(absorption, scattering);
+}
+
+fn medium_volumes_piece(origin: vec3<f32>, direction: vec3<f32>, t: f32, t_max: f32) -> ${MEDIUM_PIECE_STRUCT.wgsl_ref} {
+    var next = t_max;
+    var majorant = vec3<f32>(0.0);
+
+    let volume_count = participating_media_volumes_count(&scene_database);
+
+    for (var v = 0u; v < volume_count; v++) {
+        let volume = participating_media_volume_read(&scene_database, v);
+
+        let span = participating_media_volume_span(volume, origin, direction, t_max);
+
+        if (span.y <= span.x) {
+            // missed
+            continue;
+        }
+
+        if (span.x > t) {
+            // ahead: the piece ends where the ray enters it
+            next = min(next, span.x);
+        } else if (span.y > t) {
+            // inside: the piece ends where the ray leaves it at the latest
+            next = min(next, span.y);
+            majorant += volume.density * volume.particle_spec.extinction;
+        }
+    }
+
+    return ${MEDIUM_PIECE_STRUCT.wgsl_ref}(majorant, next);
+}
+
+fn medium_volumes_rest(origin: vec3<f32>, direction: vec3<f32>, t: f32, t_max: f32) -> ${MEDIUM_PIECE_STRUCT.wgsl_ref} {
+    var majorant = vec3<f32>(0.0);
+    var end = t_max;
+    var ahead = false;
+
+    let volume_count = participating_media_volumes_count(&scene_database);
+
+    for (var v = 0u; v < volume_count; v++) {
+        let volume = participating_media_volume_read(&scene_database, v);
+
+        let span = participating_media_volume_span(volume, origin, direction, t_max);
+
+        if (span.y <= max(span.x, t)) {
+            // missed, or already left behind
+            continue;
+        }
+
+        majorant += volume.density * volume.particle_spec.extinction;
+        end = select(span.y, max(end, span.y), ahead);
+        ahead = true;
+    }
+
+    return ${MEDIUM_PIECE_STRUCT.wgsl_ref}(majorant, end);
+}
+    `,
+    [
+        MEDIUM_COEFFICIENTS_STRUCT.declaration_chunk,
+        MEDIUM_PIECE_STRUCT.declaration_chunk,
+        chunk_participating_media_volumes_iterate,
+        chunk_participating_media_volume_sample,
+    ]
+);

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -53,7 +53,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#186@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#187@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_sample_history.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_ssr_sample_history.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_sample_history.js"],"names":[],"mappings":"AAUA,8FAA8F;AAC9F,iDAwEkD;0BAnFxB,uCAAuC"}
+{"version":3,"file":"chunk_ssr_sample_history.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_sample_history.js"],"names":[],"mappings":"AAWA,8FAA8F;AAC9F,iDAwEgF;0BApFtD,uCAAuC"}

package/src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_sample_history.js

@@ -1,84 +1,85 @@
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { chunk_project_position_from_depth } from "../../../shader/chunk/camera/chunk_project_position_from_depth.js";
-import { chunk_is_background } from "../../../shader/chunk/depth/chunk_is_background.js";
-import { chunk_plane_from_normal_and_point } from "../../../shader/chunk/geometry/plane/chunk_plane_from_normal_and_point.js";
-import { chunk_point_distance_above_plane } from "../../../shader/chunk/geometry/plane/chunk_point_distance_above_plane.js";
-import { chunk_is_on_screen_i32 } from "../../../shader/chunk/texture/chunk_is_on_screen_i32.js";
-import { chunk_texel_coordinate_to_uv } from "../../../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
-import { chunk_get_bilinear_weights } from "../../../shader/chunk/texture/sample/chunk_get_bilinear_weights.js";
-import { chunk_is_finite } from "../../../shader/chunk/math/chunk_is_finite.js";
-
-/** Resource names are supplied by ssr_reproject_shader. Validate exactly the taps we read. */
-export const chunk_ssr_sample_history = CodeChunk.from(/* language=WGSL */ `
-struct SSRHistorySample {
-    radiance: vec4f,
-    confidence: f32,
-    age: f32,
-    short_luma: f32,
-}
-
-fn ssr_sample_history(
-    uv: vec2f, position: vec3f, normal: vec3f, roughness: f32,
-    metadata: vec2f, virtual_position: vec3f, virtual_candidate: bool, plane_tolerance: f32,
-) -> SSRHistorySample {
-    var result: SSRHistorySample;
-    if (!is_finite(uv.x) || !is_finite(uv.y) || any(uv < vec2f(0.0)) || any(uv >= vec2f(1.0))) {
-        return result;
-    }
-    let size = textureDimensions(tHistory);
-    let texel = uv * vec2f(size) - 0.5;
-    let origin = vec2i(floor(texel));
-    let weights = get_bilinear_weights(fract(texel));
-    let offsets = array<vec2i, 4>(vec2i(0,0), vec2i(1,0), vec2i(0,1), vec2i(1,1));
-    let plane = plane_from_normal_and_point(normal, position);
-    for (var i = 0; i < 4; i++) {
-        let coord = origin + offsets[i];
-        if (weights[i] <= 0.0 || !is_on_screen_i32(coord, vec2i(size))) { continue; }
-        let depth = textureLoad(tPreviousDepth, coord, 0).r;
-        if (is_background(depth)) { continue; }
-        let geometry = textureLoad(tHistoryGeometry, coord, 0);
-        if (!is_finite(geometry.x) || !is_finite(geometry.y) || !is_finite(geometry.z) || !is_finite(geometry.w)) { continue; }
-        if (dot(geometry.xyz, geometry.xyz) < 0.5) { continue; }
-        let normal_agreement = dot(normal, normalize(geometry.xyz));
-        if (normal_agreement < select(0.9, 0.995, virtual_candidate) || abs(roughness - geometry.w) > 0.08) { continue; }
-        let previous_position = project_position_from_depth(
-            texel_coordinate_to_uv(vec2f(coord), size), depth, camera_previous.view_projection_matrix_inverse);
-        let plane_distance = abs(point_distance_above_plane(previous_position, plane));
-        if (!is_finite(plane_distance) || plane_distance > plane_tolerance) { continue; }
-        let previous_metadata = textureLoad(tHistoryMetadata, coord, 0);
-        if (!is_finite(previous_metadata.x) || !is_finite(previous_metadata.y)) { continue; }
-        if (!is_finite(previous_metadata.z) || !is_finite(previous_metadata.w)) { continue; }
-        // On a rough reflector, hit/miss support is itself a stochastic sample. It is
-        // not evidence that the receiving surface or the reflected scene has moved.
-        if (roughness <= 0.2 && abs(previous_metadata.y - metadata.y) > 0.25) { continue; }
-        var support = 1.0;
-        if (virtual_candidate) {
-            if (previous_metadata.y < 0.5 || previous_metadata.x <= 0.0) { continue; }
-            // Compare reflected distance from this OLD mirror point, not from today's point.
-            let expected_distance = length(virtual_position - previous_position);
-            let distance_error = abs(previous_metadata.x - expected_distance);
-            if (distance_error > max(expected_distance * 0.1, plane_tolerance)) { continue; }
-            support = min(metadata.y, previous_metadata.y);
-        }
-        let radiance = textureLoad(tHistory, coord, 0);
-        if (!is_finite(radiance.x) || !is_finite(radiance.y) || !is_finite(radiance.z) || !is_finite(radiance.w)) { continue; }
-        let w = weights[i] * support;
-        let age = clamp(previous_metadata.z, 1.0, 128.0);
-        // Reconstruct each tap's distribution variance BEFORE interpolation.
-        // E[variance/age] * E[age] can wildly inflate noise at an age boundary.
-        result.radiance += max(radiance, vec4f(0.0)) * vec4f(w,w,w,w*age);
-        result.age += age * w;
-        result.short_luma += previous_metadata.w * w;
-        result.confidence += w;
-    }
-    if (result.confidence > 1e-6) {
-        result.radiance /= result.confidence;
-        result.age /= result.confidence;
-        result.radiance.w /= result.age;
-        result.short_luma /= result.confidence;
-    }
-    return result;
-}
-`, [chunk_project_position_from_depth, chunk_is_background, chunk_plane_from_normal_and_point,
-    chunk_point_distance_above_plane, chunk_is_on_screen_i32, chunk_texel_coordinate_to_uv,
-    chunk_get_bilinear_weights, chunk_is_finite]);
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_project_position_from_depth } from "../../../shader/chunk/camera/chunk_project_position_from_depth.js";
+import { chunk_is_background } from "../../../shader/chunk/depth/chunk_is_background.js";
+import { chunk_plane_from_normal_and_point } from "../../../shader/chunk/geometry/plane/chunk_plane_from_normal_and_point.js";
+import { chunk_point_distance_above_plane } from "../../../shader/chunk/geometry/plane/chunk_point_distance_above_plane.js";
+import { chunk_is_on_screen_i32 } from "../../../shader/chunk/texture/chunk_is_on_screen_i32.js";
+import { chunk_texel_coordinate_to_uv } from "../../../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
+import { chunk_get_bilinear_filter_uv } from "../../../shader/chunk/texture/sample/chunk_get_bilinear_filter_uv.js";
+import { chunk_get_bilinear_weights } from "../../../shader/chunk/texture/sample/chunk_get_bilinear_weights.js";
+import { chunk_is_finite } from "../../../shader/chunk/math/chunk_is_finite.js";
+
+/** Resource names are supplied by ssr_reproject_shader. Validate exactly the taps we read. */
+export const chunk_ssr_sample_history = CodeChunk.from(/* language=WGSL */ `
+struct SSRHistorySample {
+    radiance: vec4f,
+    confidence: f32,
+    age: f32,
+    short_luma: f32,
+}
+
+fn ssr_sample_history(
+    uv: vec2f, position: vec3f, normal: vec3f, roughness: f32,
+    metadata: vec2f, virtual_position: vec3f, virtual_candidate: bool, plane_tolerance: f32,
+) -> SSRHistorySample {
+    var result: SSRHistorySample;
+    if (!is_finite(uv.x) || !is_finite(uv.y) || any(uv < vec2f(0.0)) || any(uv >= vec2f(1.0))) {
+        return result;
+    }
+    let size = textureDimensions(tHistory);
+    let bilinear = get_bilinear_filter_uv(uv, size);
+    let origin = vec2i(bilinear.origin);
+    let weights = get_bilinear_weights(bilinear.weights);
+    let offsets = array<vec2i, 4>(vec2i(0,0), vec2i(1,0), vec2i(0,1), vec2i(1,1));
+    let plane = plane_from_normal_and_point(normal, position);
+    for (var i = 0; i < 4; i++) {
+        let coord = origin + offsets[i];
+        if (weights[i] <= 0.0 || !is_on_screen_i32(coord, vec2i(size))) { continue; }
+        let depth = textureLoad(tPreviousDepth, coord, 0).r;
+        if (is_background(depth)) { continue; }
+        let geometry = textureLoad(tHistoryGeometry, coord, 0);
+        if (!is_finite(geometry.x) || !is_finite(geometry.y) || !is_finite(geometry.z) || !is_finite(geometry.w)) { continue; }
+        if (dot(geometry.xyz, geometry.xyz) < 0.5) { continue; }
+        let normal_agreement = dot(normal, normalize(geometry.xyz));
+        if (normal_agreement < select(0.9, 0.995, virtual_candidate) || abs(roughness - geometry.w) > 0.08) { continue; }
+        let previous_position = project_position_from_depth(
+            texel_coordinate_to_uv(vec2f(coord), size), depth, camera_previous.view_projection_matrix_inverse);
+        let plane_distance = abs(point_distance_above_plane(previous_position, plane));
+        if (!is_finite(plane_distance) || plane_distance > plane_tolerance) { continue; }
+        let previous_metadata = textureLoad(tHistoryMetadata, coord, 0);
+        if (!is_finite(previous_metadata.x) || !is_finite(previous_metadata.y)) { continue; }
+        if (!is_finite(previous_metadata.z) || !is_finite(previous_metadata.w)) { continue; }
+        // On a rough reflector, hit/miss support is itself a stochastic sample. It is
+        // not evidence that the receiving surface or the reflected scene has moved.
+        if (roughness <= 0.2 && abs(previous_metadata.y - metadata.y) > 0.25) { continue; }
+        var support = 1.0;
+        if (virtual_candidate) {
+            if (previous_metadata.y < 0.5 || previous_metadata.x <= 0.0) { continue; }
+            // Compare reflected distance from this OLD mirror point, not from today's point.
+            let expected_distance = length(virtual_position - previous_position);
+            let distance_error = abs(previous_metadata.x - expected_distance);
+            if (distance_error > max(expected_distance * 0.1, plane_tolerance)) { continue; }
+            support = min(metadata.y, previous_metadata.y);
+        }
+        let radiance = textureLoad(tHistory, coord, 0);
+        if (!is_finite(radiance.x) || !is_finite(radiance.y) || !is_finite(radiance.z) || !is_finite(radiance.w)) { continue; }
+        let w = weights[i] * support;
+        let age = clamp(previous_metadata.z, 1.0, 128.0);
+        // Reconstruct each tap's distribution variance BEFORE interpolation.
+        // E[variance/age] * E[age] can wildly inflate noise at an age boundary.
+        result.radiance += max(radiance, vec4f(0.0)) * vec4f(w,w,w,w*age);
+        result.age += age * w;
+        result.short_luma += previous_metadata.w * w;
+        result.confidence += w;
+    }
+    if (result.confidence > 1e-6) {
+        result.radiance /= result.confidence;
+        result.age /= result.confidence;
+        result.radiance.w /= result.age;
+        result.short_luma /= result.confidence;
+    }
+    return result;
+}
+`, [chunk_project_position_from_depth, chunk_is_background, chunk_plane_from_normal_and_point,
+    chunk_point_distance_above_plane, chunk_is_on_screen_i32, chunk_texel_coordinate_to_uv,
+    chunk_get_bilinear_filter_uv, chunk_get_bilinear_weights, chunk_is_finite]);

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

@@ -23,5 +23,13 @@ export class AVBOITSettings {
      * @type {boolean}
      */
     transmission_tint_from_base_color: boolean;
+    /**
+     * Virtual resolutions the warp tries per octave when the occupied slices do not fit the physical
+     * budget. `1` halves, as the deck does; `4` adds three steps between each octave and the next, so the
+     * occupied count lands closer to the budget (`shader_avboit_build_warp`, AVBOIT ledger entry 27), for
+     * about a microsecond per resolution tried on an RTX 4090 (entry 28).
+     * @type {number}
+     */
+    warp_steps_per_octave: number;
 }
 //# sourceMappingURL=AVBOITSettings.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"AVBOITSettings.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSettings.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH;IAEI;;;;;;;;;;;;;OAaG;IACH,mCAFU,OAAO,CAEyB;CAC7C"}
+{"version":3,"file":"AVBOITSettings.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSettings.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH;IAEI;;;;;;;;;;;;;OAaG;IACH,mCAFU,OAAO,CAEyB;IAE1C;;;;;;OAMG;IACH,uBAFU,MAAM,CAEU;CAC7B"}

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

@@ -24,4 +24,13 @@ export class AVBOITSettings {
      * @type {boolean}
      */
     transmission_tint_from_base_color = false;
+
+    /**
+     * Virtual resolutions the warp tries per octave when the occupied slices do not fit the physical
+     * budget. `1` halves, as the deck does; `4` adds three steps between each octave and the next, so the
+     * occupied count lands closer to the budget (`shader_avboit_build_warp`, AVBOIT ledger entry 27), for
+     * about a microsecond per resolution tried on an RTX 4090 (entry 28).
+     * @type {number}
+     */
+    warp_steps_per_octave = 4;
 }

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

@@ -34,6 +34,29 @@
  * channel without the method is always asked.
  */
 export type AVBOITSideChannel = {
+    /**
+     * Optional optics preparation before occupancy; at most one producer per view. Inputs are
+     * immutable opaque resources; the light clusters, the shadow atlas and the GI mode are the ones
+     * the transparent meshes are lit by. The returned background is read by the one shared resolve.
+     * Keep prepared state per graph/camera, not on an entity or in a global current-view slot.
+     */
+    avboit_prepare?: (args: {
+        graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+        view_ctx: import("../../../view/GPUViewContext.js").GPUViewContext;
+        camera: number;
+        color_texture: number;
+        depth_texture: number;
+        normal_texture: number;
+        hzb_texture: number;
+        environment_texture: number;
+        light_cluster_parameters: number;
+        light_cluster_lookup: number;
+        light_cluster_data: number;
+        shadowmap_atlas: number;
+        indirect_lighting_mode: import("../../../ShadeIndirectLightingMode.js").ShadeIndirectLightingMode;
+    }) => {
+        background_color?: number;
+    };
     /**
      * add the channel's slices to the occupancy bits; returns the bits'
      * handle after the write. `cluster_parameters` is the frame's depth curve (`avboit_build_depth_curve`).
@@ -69,7 +92,11 @@ export type AVBOITSideChannel = {
     };
     /**
      * draw the
-     * channel's fragments into the accumulators; returns their handles after the draw.
+     * channel's fragments into the accumulators; returns their handles after the draw. A channel
+     * whose fragments splat into the volume adds `avboit_footprint_bias` (of `fwidth` of the fragment's
+     * virtual slice coordinate, taken in uniform control flow) to its lookup, as the mesh draw does, or
+     * a surface it draws at an angle occludes itself in an 8-pixel pattern; one whose fragments write
+     * nothing into the volume passes `0`.
      * `volumetrics_irradiance` is what a fragment standing in a froxel is lit by
      * (`chunk_volumetrics_irradiance_sh`), for a channel whose fragments are lit: the renderer's
      * indirect lighting, whichever mode it runs, and the scene's lights, shadowed and attenuated by

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

@@ -1 +1 @@
-{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAoCc,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAM9D,MAAM,OAAO"}
+{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCc,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QACjH,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QACzF,aAAmB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAC3E,WAAiB,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAC;QACvD,wBAA8B,EAAE,MAAM,CAAC;QAAC,oBAAoB,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QACjG,eAAqB,EAAE,MAAM,CAAC;QAC9B,sBAA4B,EAAE,OAAO,uCAAuC,EAAE,yBAAyB,CAAC;KACrG,KAAK;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAC;;;;;sBAKtB,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAU9D,MAAM,OAAO"}

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

@@ -34,6 +34,18 @@
  * channel without the method is always asked.
  *
  * @typedef {object} AVBOITSideChannel
+ * @property {(args: {graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph,
+ *     view_ctx: import("../../../view/GPUViewContext.js").GPUViewContext, camera: number,
+ *     color_texture: number, depth_texture: number, normal_texture: number,
+ *     hzb_texture: number, environment_texture: number,
+ *     light_cluster_parameters: number, light_cluster_lookup: number, light_cluster_data: number,
+ *     shadowmap_atlas: number,
+ *     indirect_lighting_mode: import("../../../ShadeIndirectLightingMode.js").ShadeIndirectLightingMode,
+ * }) => {background_color?: number}} [avboit_prepare]
+ *     Optional optics preparation before occupancy; at most one producer per view. Inputs are
+ *     immutable opaque resources; the light clusters, the shadow atlas and the GI mode are the ones
+ *     the transparent meshes are lit by. The returned background is read by the one shared resolve.
+ *     Keep prepared state per graph/camera, not on an entity or in a global current-view slot.
  * @property {(args: {
  *     graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph,
  *     camera: number,
@@ -65,7 +77,11 @@
  *     volumetrics_irradiance: {Y: number, CoCg: number},
  *     accumulators: {color: number, norm: number, extinction: number, emission: number},
  * }) => {color: number, norm: number, extinction: number, emission: number}} avboit_draw draw the
- *     channel's fragments into the accumulators; returns their handles after the draw.
+ *     channel's fragments into the accumulators; returns their handles after the draw. A channel
+ *     whose fragments splat into the volume adds `avboit_footprint_bias` (of `fwidth` of the fragment's
+ *     virtual slice coordinate, taken in uniform control flow) to its lookup, as the mesh draw does, or
+ *     a surface it draws at an angle occludes itself in an 8-pixel pattern; one whose fragments write
+ *     nothing into the volume passes `0`.
  *     `volumetrics_irradiance` is what a fragment standing in a froxel is lit by
  *     (`chunk_volumetrics_irradiance_sh`), for a channel whose fragments are lit: the renderer's
  *     indirect lighting, whichever mode it runs, and the scene's lights, shadowed and attenuated by

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

@@ -20,8 +20,9 @@ export const AVBOIT_PHYSICAL_SLICES: number;
  * this value: 1.6 cm at 10 m, 3.2 cm at 20 m, 8 cm at 50 m. The draw's two-slice bias means two
  * surfaces need more than two slices between them, so 5 cm of separation resolves out to roughly
  * 15 m. At 1024 the same numbers were four times coarser and 5 cm at 10 m already blended (ledger
- * entry 15). The costs of going up are 128 occupancy words instead of 32, a 16 KB LUT, and a longer
- * single-lane loop in the warp build — none of which registers.
+ * entry 15). The costs of going up are 128 occupancy words instead of 32, a 16 KB LUT, and 4,097 LUT
+ * entries for the warp build to write: 136 µs while the build was a single invocation (ledger entry 27),
+ * 3 µs as a workgroup (entry 28).
  * @type {number}
  */
 export const AVBOIT_VIRTUAL_SLICES_MAX: number;
@@ -55,10 +56,13 @@ export const AVBOIT_EXTINCTION_MAX: number;
 /**
  * Transmittance below which a fragment is fully occluded as far as the volume can tell: the integral
  * saturates at `1.0`, which is `exp(-AVBOIT_EXTINCTION_MAX) = 1/256`. The draw discards a fragment
- * whose sampled transmittance is at or below this in every channel before shading it. What that
- * costs in correctness is bounded: the fragment's own extinction no longer joins the total, so the
- * background is weighted by at most `1/256` instead of something smaller — below what the 8-bit
- * volume resolves anyway.
+ * whose sampled transmittance is at or below this in every channel before shading it. Where the
+ * 1/8-resolution volume is right at the full-resolution pixel, what that costs is bounded: the
+ * fragment's own extinction no longer joins the total, so the background is weighted by at most
+ * `1/256` instead of something smaller — below what the 8-bit volume resolves anyway. Where it is not
+ * — behind a gap narrower than a voxel in a near-opaque layer — the volume calls the pixel extinct and
+ * the surface seen through the gap is discarded, where the resolve's normalization would have drawn
+ * it. The deck's zero-transmittance cull shares the limit (ledger entry 26).
  * @type {number}
  */
 export const AVBOIT_EXTINCT_TRANSMITTANCE: number;
@@ -82,7 +86,9 @@ export const AVBOIT_FIELD_MASK: number;
  * How far toward the camera, in virtual slices, the draw pass samples the integral so that a surface
  * does not occlude itself through its own linear splat. With the exclusive-prefix storage convention
  * the analytic minimum is 1.5; the deck uses 2. Events closer together than this do not occlude each
- * other and degrade to weighted blending.
+ * other and degrade to weighted blending. A surface tilted away from the camera adds its footprint on
+ * top (`avboit_footprint_bias`): the base bias is for a surface splatted at its own depth, and the
+ * draw also reads the neighbouring voxel columns, where a tilted one was splatted nearer.
  * @type {number}
  */
 export const AVBOIT_SAMPLE_BIAS_SLICES: number;

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

@@ -1 +1 @@
-{"version":3,"file":"AVBOIT_CONSTANTS.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOIT_CONSTANTS.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AACH,qCAFU,MAAM,CAE0B;AAE1C;;;;;;;;;;;;;;;GAeG;AACH,wCAFU,MAAM,CAE8B;AAE9C;;;GAGG;AACH,qCAFU,MAAM,CAEqD;AAErE;;;;GAIG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;;;;GAMG;AACH,6CAFU,MAAM,CAEkC;AAElD;;;;;;GAMG;AACH,oCAFU,MAAM,CAEmC;AAEnD;;;;;;;;GAQG;AACH,2CAFU,MAAM,CAEoC;AAEpD;;;;GAIG;AACH,sCAFU,MAAM,CAE2B;AAE3C;;;GAGG;AACH,gCAFU,MAAM,CAEoB;AAEpC;;;GAGG;AACH,gCAFU,MAAM,CAE8C;AAE9D;;;;;;GAMG;AACH,wCAFU,MAAM,CAE6B;AAE7C;;;;;GAKG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;GAIG;AACH,sDAAmD;AAEnD;;;GAGG;AACH,8CAFU,MAAM,CAEiC"}
+{"version":3,"file":"AVBOIT_CONSTANTS.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOIT_CONSTANTS.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AACH,qCAFU,MAAM,CAE0B;AAE1C;;;;;;;;;;;;;;;;GAgBG;AACH,wCAFU,MAAM,CAE8B;AAE9C;;;GAGG;AACH,qCAFU,MAAM,CAEqD;AAErE;;;;GAIG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;;;;GAMG;AACH,6CAFU,MAAM,CAEkC;AAElD;;;;;;GAMG;AACH,oCAFU,MAAM,CAEmC;AAEnD;;;;;;;;;;;GAWG;AACH,2CAFU,MAAM,CAEoC;AAEpD;;;;GAIG;AACH,sCAFU,MAAM,CAE2B;AAE3C;;;GAGG;AACH,gCAFU,MAAM,CAEoB;AAEpC;;;GAGG;AACH,gCAFU,MAAM,CAE8C;AAE9D;;;;;;;;GAQG;AACH,wCAFU,MAAM,CAE6B;AAE7C;;;;;GAKG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;GAIG;AACH,sDAAmD;AAEnD;;;GAGG;AACH,8CAFU,MAAM,CAEiC"}

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

@@ -22,8 +22,9 @@ export const AVBOIT_PHYSICAL_SLICES = 128;
  * this value: 1.6 cm at 10 m, 3.2 cm at 20 m, 8 cm at 50 m. The draw's two-slice bias means two
  * surfaces need more than two slices between them, so 5 cm of separation resolves out to roughly
  * 15 m. At 1024 the same numbers were four times coarser and 5 cm at 10 m already blended (ledger
- * entry 15). The costs of going up are 128 occupancy words instead of 32, a 16 KB LUT, and a longer
- * single-lane loop in the warp build — none of which registers.
+ * entry 15). The costs of going up are 128 occupancy words instead of 32, a 16 KB LUT, and 4,097 LUT
+ * entries for the warp build to write: 136 µs while the build was a single invocation (ledger entry 27),
+ * 3 µs as a workgroup (entry 28).
  * @type {number}
  */
 export const AVBOIT_VIRTUAL_SLICES_MAX = 4096;
@@ -62,10 +63,13 @@ export const AVBOIT_EXTINCTION_MAX = Math.log(256);
 /**
  * Transmittance below which a fragment is fully occluded as far as the volume can tell: the integral
  * saturates at `1.0`, which is `exp(-AVBOIT_EXTINCTION_MAX) = 1/256`. The draw discards a fragment
- * whose sampled transmittance is at or below this in every channel before shading it. What that
- * costs in correctness is bounded: the fragment's own extinction no longer joins the total, so the
- * background is weighted by at most `1/256` instead of something smaller — below what the 8-bit
- * volume resolves anyway.
+ * whose sampled transmittance is at or below this in every channel before shading it. Where the
+ * 1/8-resolution volume is right at the full-resolution pixel, what that costs is bounded: the
+ * fragment's own extinction no longer joins the total, so the background is weighted by at most
+ * `1/256` instead of something smaller — below what the 8-bit volume resolves anyway. Where it is not
+ * — behind a gap narrower than a voxel in a near-opaque layer — the volume calls the pixel extinct and
+ * the surface seen through the gap is discarded, where the resolve's normalization would have drawn
+ * it. The deck's zero-transmittance cull shares the limit (ledger entry 26).
  * @type {number}
  */
 export const AVBOIT_EXTINCT_TRANSMITTANCE = 1 / 256;
@@ -93,7 +97,9 @@ export const AVBOIT_FIELD_MASK = (1 << AVBOIT_FIELD_BITS) - 1;
  * How far toward the camera, in virtual slices, the draw pass samples the integral so that a surface
  * does not occlude itself through its own linear splat. With the exclusive-prefix storage convention
  * the analytic minimum is 1.5; the deck uses 2. Events closer together than this do not occlude each
- * other and degrade to weighted blending.
+ * other and degrade to weighted blending. A surface tilted away from the camera adds its footprint on
+ * top (`avboit_footprint_bias`): the base bias is for a surface splatted at its own depth, and the
+ * draw also reads the neighbouring voxel columns, where a tilted one was splatted nearer.
  * @type {number}
  */
 export const AVBOIT_SAMPLE_BIAS_SLICES = 2.0;