@woosh/meep-engine 3.14.6 → 3.16.0

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

@@ -0,0 +1,38 @@
+import { assert } from "../../../../../core/assert.js";
+import { build_light_cluster_parameters } from "../../../light/cluster/build_light_cluster_parameters.js";
+import { AVBOIT_DEPTH_CURVE_NEAR_OFFSET, AVBOIT_VIRTUAL_SLICES_MAX } from "./AVBOIT_CONSTANTS.js";
+
+/**
+ * The depth curve of the extinction volume, as `cluster_parameters` for the engine's log slicing
+ * (`cluster_depth_to_z_slice`), built for the finest virtual resolution.
+ *
+ * `build_light_cluster_parameters` is the light clusters' and the froxels' curve: slice
+ * `= log2(depth · B + O) · scale`, with `scale` deciding how much of the range is logarithmic and
+ * `near_offset` where it starts. The choice here is pure log from the offset plane — `scale` such that
+ * `O` comes out zero — because the adaptive warp makes near-plane precision free (empty slices cost no
+ * physical slice), so there is nothing to gain by flattening the curve as the light clusters do.
+ *
+ * Slice thickness at view depth `z` is then `z · ln(far / offset) / (V_max - 1)`; the numbers for the
+ * defaults are on `AVBOIT_VIRTUAL_SLICES_MAX`.
+ *
+ * @param {number} near camera near plane, world units
+ * @param {number} far camera far plane, world units
+ * @param {Float32Array|number[]} [result] three floats
+ * @returns {Float32Array|number[]} `result`
+ */
+export function avboit_build_depth_curve(near, far, result = new Float32Array(3)) {
+    assert.isNumber(near, 'near');
+    assert.isNumber(far, 'far');
+    assert.greaterThan(far, near, 'far must be greater than near');
+
+    const offset = near + AVBOIT_DEPTH_CURVE_NEAR_OFFSET;
+    const scale = (AVBOIT_VIRTUAL_SLICES_MAX - 1) / Math.log2(far / offset);
+
+    return build_light_cluster_parameters(
+        result, 0,
+        AVBOIT_VIRTUAL_SLICES_MAX,
+        near, far,
+        AVBOIT_DEPTH_CURVE_NEAR_OFFSET,
+        scale,
+    );
+}

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

@@ -0,0 +1,45 @@
+/**
+ * The fragment stage of the AVBOIT draw pass, shared verbatim by the IBL and Brick4 pipelines
+ * (`shader_avboit_draw_ibl`, `shader_avboit_draw_brick4`), which differ only in which
+ * `forward_shade_standard_fragment` they link and in one storage buffer in the view group. Same
+ * arrangement as the two MBOIT resolve shaders, with the body held in one place.
+ *
+ * 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 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
+ * changes is in `AVBOIT_EXTINCT_TRANSMITTANCE`.
+ *
+ * @type {string}
+ */
+export const AVBOIT_DRAW_FRAGMENT_BODY: string;
+/**
+ * Dependencies of {@link AVBOIT_DRAW_FRAGMENT_BODY} other than the shading chunk each pipeline picks.
+ * @type {CodeChunk[]}
+ */
+export const AVBOIT_DRAW_FRAGMENT_DEPENDENCIES: CodeChunk[];
+/**
+ * The four additive `rgba16float` targets, in `AVBOITDrawOutput` order.
+ * @type {GPUColorTargetState[]}
+ */
+export const AVBOIT_DRAW_TARGETS: GPUColorTargetState[];
+//# sourceMappingURL=avboit_draw_fragment_body.d.ts.map

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

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

@@ -0,0 +1,139 @@
+import { chunk_sample_volumetrics } from "../../../deferred/chunk_sample_volumetrics.js";
+import { chunk_get_view_space_depth } from "../../../shader/chunk/depth/chunk_get_view_space_depth.js";
+import { chunk_unjitter_uv } from "../../../shader/chunk/texture/chunk_unjitter_uv.js";
+import { FORWARD_VERTEX_SHADER_STRUCT } from "../../forward/FORWARD_VERTEX_SHADER_STRUCT.js";
+import { OIT_COVERAGE_MAX } from "../oit/OIT_CONSTANTS.js";
+import { AVBOIT_EXTINCT_TRANSMITTANCE } from "./AVBOIT_CONSTANTS.js";
+import { chunk_avboit_sample_transmittance } from "./chunk_avboit_sample_transmittance.js";
+import { chunk_avboit_transmission_tint } from "./chunk_avboit_transmission_tint.js";
+
+/**
+ * The fragment stage of the AVBOIT draw pass, shared verbatim by the IBL and Brick4 pipelines
+ * (`shader_avboit_draw_ibl`, `shader_avboit_draw_brick4`), which differ only in which
+ * `forward_shade_standard_fragment` they link and in one storage buffer in the view group. Same
+ * arrangement as the two MBOIT resolve shaders, with the body held in one place.
+ *
+ * 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 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
+ * changes is in `AVBOIT_EXTINCT_TRANSMITTANCE`.
+ *
+ * @type {string}
+ */
+export const AVBOIT_DRAW_FRAGMENT_BODY =
+    //language=WGSL
+    `
+struct AVBOITDrawOutput {
+    @location(0) color : vec4<f32>,
+    @location(1) norm : vec4<f32>,
+    @location(2) extinction : vec4<f32>,
+    @location(3) emission : vec4<f32>,
+}
+
+@fragment
+fn main(
+    @builtin(front_facing) front_facing : bool,
+    vert: ${FORWARD_VERTEX_SHADER_STRUCT.wgsl_ref},
+) -> AVBOITDrawOutput {
+
+    // need to unjitter UV to account for TAA
+    var vert_adjusted = vert;
+    vert_adjusted.uv = unjitter_uv(vert.uv, view.jitter);
+
+    // linear view depth (vert.position is @builtin(position); .z is device depth) and screen uv,
+    // for the volume lookup and the fog composite alike
+    let frag_view_depth = get_view_space_depth(vert_adjusted.position.z, camera);
+    let frag_screen_uv = vert_adjusted.position.xy / vec2<f32>(f32(view.width), f32(view.height));
+
+    let transmittance = avboit_sample_transmittance(&warp, tIntegral, sLinear, frag_screen_uv, frag_view_depth);
+
+    if (all(transmittance <= vec3<f32>(${AVBOIT_EXTINCT_TRANSMITTANCE}))) {
+        // nothing this fragment contributes survives what is in front of it; skip the shading
+        discard;
+    }
+
+    let shaded = forward_shade_standard_fragment(vert_adjusted, front_facing);
+
+    // composite volumetric fog between the camera and this fragment
+    let volumetrics = sample_volumetrics(frag_view_depth, frag_screen_uv, vert_adjusted.position.xy);
+
+    let color = shaded.rgb * volumetrics.w + volumetrics.xyz;
+
+    // full opacity would be zero transmittance, whose logarithm breaks the accumulators
+    let coverage = min(shaded.a, ${OIT_COVERAGE_MAX});
+
+    // the same tint the splat recorded, from the same inputs
+    var tint = vec3<f32>(1.0);
+    let f_transmission = material_info.transmission_factor;
+    if (f_transmission > 0.0) {
+        let t_diffuse = textureSample(texture_diffuse, texture_diffuse_sampler, vert_adjusted.uv);
+        let base_color = (t_diffuse.rgb / max(t_diffuse.a, 1e-7)) * vert.color;
+        tint = avboit_transmission_tint(base_color, f_transmission * f32(warp.tint_from_base_color));
+    }
+
+    let self_transmittance = (1.0 - coverage) * tint;
+
+    var out: AVBOITDrawOutput;
+
+    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;
+}
+    `;
+
+/**
+ * Dependencies of {@link AVBOIT_DRAW_FRAGMENT_BODY} other than the shading chunk each pipeline picks.
+ * @type {CodeChunk[]}
+ */
+export const AVBOIT_DRAW_FRAGMENT_DEPENDENCIES = [
+    FORWARD_VERTEX_SHADER_STRUCT.declaration_chunk,
+    chunk_unjitter_uv,
+    chunk_get_view_space_depth,
+    chunk_sample_volumetrics,
+    chunk_avboit_sample_transmittance,
+    chunk_avboit_transmission_tint,
+];
+
+/**
+ * The four additive `rgba16float` targets, in `AVBOITDrawOutput` order.
+ * @type {GPUColorTargetState[]}
+ */
+export const AVBOIT_DRAW_TARGETS = ["color", "norm", "extinction", "emission"].map(label => ({
+    label,
+    format: "rgba16float",
+    blend: {
+        color: {
+            operation: "add",
+            srcFactor: "one",
+            dstFactor: "one",
+        },
+        alpha: {
+            operation: "add",
+            srcFactor: "one",
+            dstFactor: "one",
+        }
+    }
+}));

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

@@ -0,0 +1,37 @@
+/**
+ * Test-only helpers shared by the AVBOIT emulator specs: a warp binding built by hand the way
+ * `shader_avboit_build_warp` builds it on the GPU, and the depth that lands on a given finest-level
+ * virtual slice, so a spec can reason in slices and still feed the real curve.
+ *
+ * Not a spec, and not shipped: nothing outside `*.spec.js` imports it.
+ */
+/**
+ * The emulator hands a `u32` with its top bit set back as a negative JS number; compare unsigned.
+ * @param {number} x
+ * @returns {number}
+ */
+export function u32(x: number): number;
+/**
+ * @param {number[]} occupancy one flag per virtual slice; its length is the active `V`
+ * @param {object} [overrides] header fields to override
+ * @returns {object} a warp binding as the shaders see it
+ */
+export function make_warp(occupancy: number[], overrides?: object): object;
+/**
+ * The view depth whose finest-level slice coordinate is `slice`, inverting the pure-log curve
+ * `avboit_build_depth_curve` builds: `slice = log2(depth · B + O) · scale`.
+ *
+ * @param {ArrayLike<number>} curve cluster parameters
+ * @param {number} slice in `[0, AVBOIT_VIRTUAL_SLICES_MAX]`
+ * @returns {number}
+ */
+export function depth_for_finest_slice(curve: ArrayLike<number>, slice: number): number;
+/**
+ * The view depth whose coordinate at the active resolution `V` is `virtual_slice`.
+ *
+ * @param {object} warp
+ * @param {number} virtual_slice in `[0, V]`
+ * @returns {number}
+ */
+export function depth_for_virtual_slice(warp: object, virtual_slice: number): number;
+//# sourceMappingURL=avboit_spec_support.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"avboit_spec_support.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/avboit_spec_support.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AAEH;;;;GAIG;AACH,uBAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,qCAJW,MAAM,EAAE,cACR,MAAM,GACJ,MAAM,CAsBlB;AAED;;;;;;;GAOG;AACH,8CAJW,UAAU,MAAM,CAAC,SACjB,MAAM,GACJ,MAAM,CAKlB;AAED;;;;;;GAMG;AACH,8CAJW,MAAM,iBACN,MAAM,GACJ,MAAM,CAOlB"}

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

@@ -0,0 +1,73 @@
+import { AVBOIT_PHYSICAL_SLICES, AVBOIT_VIRTUAL_SLICES_MAX } from "./AVBOIT_CONSTANTS.js";
+import { avboit_build_depth_curve } from "./avboit_build_depth_curve.js";
+
+/**
+ * Test-only helpers shared by the AVBOIT emulator specs: a warp binding built by hand the way
+ * `shader_avboit_build_warp` builds it on the GPU, and the depth that lands on a given finest-level
+ * virtual slice, so a spec can reason in slices and still feed the real curve.
+ *
+ * Not a spec, and not shipped: nothing outside `*.spec.js` imports it.
+ */
+
+/**
+ * The emulator hands a `u32` with its top bit set back as a negative JS number; compare unsigned.
+ * @param {number} x
+ * @returns {number}
+ */
+export function u32(x) {
+    return x >>> 0;
+}
+
+/**
+ * @param {number[]} occupancy one flag per virtual slice; its length is the active `V`
+ * @param {object} [overrides] header fields to override
+ * @returns {object} a warp binding as the shaders see it
+ */
+export function make_warp(occupancy, overrides = {}) {
+    const lut = new Uint32Array(occupancy.length + 1);
+    let prefix = 0;
+    for (let v = 0; v < occupancy.length; v++) {
+        lut[v] = (prefix << 1) | occupancy[v];
+        prefix += occupancy[v];
+    }
+    lut[occupancy.length] = prefix << 1;
+
+    return {
+        virtual_count: occupancy.length,
+        occupied_count: prefix,
+        physical_count: AVBOIT_PHYSICAL_SLICES,
+        voxel_width: 1,
+        voxel_height: 1,
+        tint_from_base_color: 0,
+        cluster_parameters: avboit_build_depth_curve(0.1, 200),
+        lut,
+        ...overrides,
+    };
+}
+
+/**
+ * The view depth whose finest-level slice coordinate is `slice`, inverting the pure-log curve
+ * `avboit_build_depth_curve` builds: `slice = log2(depth · B + O) · scale`.
+ *
+ * @param {ArrayLike<number>} curve cluster parameters
+ * @param {number} slice in `[0, AVBOIT_VIRTUAL_SLICES_MAX]`
+ * @returns {number}
+ */
+export function depth_for_finest_slice(curve, slice) {
+    const [B, O, scale] = curve;
+    return (Math.pow(2, slice / scale) - O) / B;
+}
+
+/**
+ * The view depth whose coordinate at the active resolution `V` is `virtual_slice`.
+ *
+ * @param {object} warp
+ * @param {number} virtual_slice in `[0, V]`
+ * @returns {number}
+ */
+export function depth_for_virtual_slice(warp, virtual_slice) {
+    return depth_for_finest_slice(
+        warp.cluster_parameters,
+        virtual_slice * AVBOIT_VIRTUAL_SLICES_MAX / warp.virtual_count
+    );
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Accumulated counts back to normalized extinction. Not clamped: a field that summed past 255 reads
+ * above 1.0 here and saturates in the integration, which is where the running value is kept.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_counts_to_extinction: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_counts_to_extinction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_counts_to_extinction.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_counts_to_extinction.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,gDAFU,SAAS,CASjB;0BAhBwB,uCAAuC"}

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

@@ -0,0 +1,17 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { AVBOIT_EXTINCTION_SCALE } from "./AVBOIT_CONSTANTS.js";
+
+/**
+ * Accumulated counts back to normalized extinction. Not clamped: a field that summed past 255 reads
+ * above 1.0 here and saturates in the integration, which is where the running value is kept.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_counts_to_extinction = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_counts_to_extinction(counts: vec3<u32>) -> vec3<f32> {
+    return vec3<f32>(counts) / ${AVBOIT_EXTINCTION_SCALE}.0;
+}
+    `
+);

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

@@ -0,0 +1,11 @@
+/**
+ * One occupancy word dilated by one slice each side. `below` carries bit 31 of the previous word
+ * into bit 0, `above` carries bit 0 of the next word already shifted up to bit 31, so runs grow
+ * across word boundaries too. The margin is what keeps a fragment on the edge of a meshlet's bounds
+ * from linear-splatting into a neighbouring run.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_dilate_word: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_dilate_word.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_dilate_word.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_dilate_word.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,uCAFU,SAAS,CASjB;0BAjBwB,uCAAuC"}

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

@@ -0,0 +1,18 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+
+/**
+ * One occupancy word dilated by one slice each side. `below` carries bit 31 of the previous word
+ * into bit 0, `above` carries bit 0 of the next word already shifted up to bit 31, so runs grow
+ * across word boundaries too. The margin is what keeps a fragment on the edge of a meshlet's bounds
+ * from linear-splatting into a neighbouring run.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_dilate_word = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_dilate_word(x: u32, below: u32, above: u32) -> u32 {
+    return x | (x << 1u) | below | (x >> 1u) | above;
+}
+    `
+);

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

@@ -0,0 +1,9 @@
+/**
+ * Normalized extinction to the 8-bit counts the splat adds: rounded to nearest, so an event below
+ * half a count registers nothing — the finest single-event occlusion the volume holds is about 2 %.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_extinction_to_counts: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_extinction_to_counts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_extinction_to_counts.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_extinction_to_counts.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,gDAFU,SAAS,CASjB;0BAhBwB,uCAAuC"}

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

@@ -0,0 +1,17 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { AVBOIT_EXTINCTION_SCALE } from "./AVBOIT_CONSTANTS.js";
+
+/**
+ * Normalized extinction to the 8-bit counts the splat adds: rounded to nearest, so an event below
+ * half a count registers nothing — the finest single-event occlusion the volume holds is about 2 %.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_extinction_to_counts = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_extinction_to_counts(extinction: vec3<f32>) -> vec3<u32> {
+    return vec3<u32>(saturate(extinction) * ${AVBOIT_EXTINCTION_SCALE}.0 + 0.5);
+}
+    `
+);

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

@@ -0,0 +1,9 @@
+/**
+ * The inverse of `avboit_transmittance_to_extinction`: `exp(-e · ln 256)` per channel, what the
+ * draw applies to a sampled integral.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_extinction_to_transmittance: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_extinction_to_transmittance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_extinction_to_transmittance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_extinction_to_transmittance.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,uDAFU,SAAS,CASjB;0BAhBwB,uCAAuC"}

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

@@ -0,0 +1,17 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { AVBOIT_EXTINCTION_MAX } from "./AVBOIT_CONSTANTS.js";
+
+/**
+ * The inverse of `avboit_transmittance_to_extinction`: `exp(-e · ln 256)` per channel, what the
+ * draw applies to a sampled integral.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_extinction_to_transmittance = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_extinction_to_transmittance(extinction: vec3<f32>) -> vec3<f32> {
+    return exp(-extinction * ${AVBOIT_EXTINCTION_MAX});
+}
+    `
+);

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

@@ -0,0 +1,15 @@
+/**
+ * Halve the slice resolution of one occupancy word: bit `j` of the 16-bit result is bit `2j` OR bit
+ * `2j + 1` of the input — the even bits compacted, OR the odd bits compacted.
+ *
+ * Both compactions come from the BVH builder's 2D Morton decode. Only its `.x` is used: for a 32-bit
+ * code that function's `.x` is the even bits compacted to 16, while its `.y` is not the odd bits (the
+ * `<< 31` that separates the odd bits works in the 16-bit variant, where the shift is 15, and cannot
+ * in 32 bits). Shifting the word right by one puts the odd bits on even positions, so the same `.x`
+ * serves both halves.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_fold_pairs: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_fold_pairs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_fold_pairs.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_fold_pairs.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,sCAFU,SAAS,CAWjB;0BAvBwB,uCAAuC"}

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

@@ -0,0 +1,25 @@
+import { chunk_decode32_morton2 } from "../../../shader/chunk/bvh/morton/chunk_decode32_morton2.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+
+/**
+ * Halve the slice resolution of one occupancy word: bit `j` of the 16-bit result is bit `2j` OR bit
+ * `2j + 1` of the input — the even bits compacted, OR the odd bits compacted.
+ *
+ * Both compactions come from the BVH builder's 2D Morton decode. Only its `.x` is used: for a 32-bit
+ * code that function's `.x` is the even bits compacted to 16, while its `.y` is not the odd bits (the
+ * `<< 31` that separates the odd bits works in the 16-bit variant, where the shift is 15, and cannot
+ * in 32 bits). Shifting the word right by one puts the odd bits on even positions, so the same `.x`
+ * serves both halves.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_fold_pairs = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_fold_pairs(x: u32) -> u32 {
+    return decode32_morton2(x).x | decode32_morton2(x >> 1u).x;
+}
+    `, [
+        chunk_decode32_morton2,
+    ]
+);

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

@@ -0,0 +1,17 @@
+/**
+ * The normalized depth coordinate into the integral texture for a fragment at `z_view` (plan §3.8).
+ *
+ * The sample bias is applied in *virtual* slices before the warp: inside an occupied run that is the
+ * same as biasing the physical coordinate; at the start of a run it walks into the gap before it,
+ * where the warp is flat, and the sample reads the previous run's total rather than two slices into a
+ * run that may be arbitrarily far away in depth.
+ *
+ * The integral holds `P + 1` texels, one per slice *boundary*, so physical coordinate `p` reads texel
+ * centre `(p + 0.5) / (P + 1)`: a run boundary lands exactly on a texel and the sample is the sum of
+ * the slices before it, with no share of the slice after.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_integral_depth_coordinate: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_integral_depth_coordinate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_integral_depth_coordinate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_integral_depth_coordinate.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,qDAFU,SAAS,CAgBjB;0BAlCwB,uCAAuC"}

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

@@ -0,0 +1,35 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { AVBOIT_SAMPLE_BIAS_SLICES } from "./AVBOIT_CONSTANTS.js";
+import { AVBOIT_WARP_STRUCT } from "./AVBOIT_WARP_STRUCT.js";
+import { chunk_avboit_view_depth_to_virtual } from "./chunk_avboit_view_depth_to_virtual.js";
+import { chunk_avboit_warp } from "./chunk_avboit_warp.js";
+
+/**
+ * The normalized depth coordinate into the integral texture for a fragment at `z_view` (plan §3.8).
+ *
+ * The sample bias is applied in *virtual* slices before the warp: inside an occupied run that is the
+ * same as biasing the physical coordinate; at the start of a run it walks into the gap before it,
+ * where the warp is flat, and the sample reads the previous run's total rather than two slices into a
+ * run that may be arbitrarily far away in depth.
+ *
+ * The integral holds `P + 1` texels, one per slice *boundary*, so physical coordinate `p` reads texel
+ * centre `(p + 0.5) / (P + 1)`: a run boundary lands exactly on a texel and the sample is the sum of
+ * the slices before it, with no share of the slice after.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_integral_depth_coordinate = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_integral_depth_coordinate(warp: ptr<storage, ${AVBOIT_WARP_STRUCT.wgsl_ref}, read>, z_view: f32) -> f32 {
+    let v = avboit_view_depth_to_virtual(warp, z_view);
+    let v_biased = max(v - ${AVBOIT_SAMPLE_BIAS_SLICES}, 0.0);
+    let p = avboit_warp(warp, v_biased);
+    return (p + 0.5) / f32((*warp).physical_count + 1u);
+}
+    `, [
+        AVBOIT_WARP_STRUCT.declaration_chunk,
+        chunk_avboit_view_depth_to_virtual,
+        chunk_avboit_warp,
+    ]
+);

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

@@ -0,0 +1,11 @@
+/**
+ * The inclusive range of finest-level virtual slices a depth interval covers, dilated by
+ * `AVBOIT_OCCUPANCY_DILATION` each side and clamped to the volume. Both ends are continuous slice
+ * coordinates from `cluster_depth_to_z_slice`, so a value of exactly `V_max` (the far plane) lands
+ * on the last slice.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_occupancy_range: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_occupancy_range.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_occupancy_range.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_occupancy_range.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,2CAFU,SAAS,CAWjB;0BApBwB,uCAAuC"}

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

@@ -0,0 +1,21 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { AVBOIT_OCCUPANCY_DILATION, AVBOIT_VIRTUAL_SLICES_MAX } from "./AVBOIT_CONSTANTS.js";
+
+/**
+ * The inclusive range of finest-level virtual slices a depth interval covers, dilated by
+ * `AVBOIT_OCCUPANCY_DILATION` each side and clamped to the volume. Both ends are continuous slice
+ * coordinates from `cluster_depth_to_z_slice`, so a value of exactly `V_max` (the far plane) lands
+ * on the last slice.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_occupancy_range = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_occupancy_range(slice_near: f32, slice_far: f32) -> vec2<i32> {
+    let first = max(i32(floor(slice_near)) - ${AVBOIT_OCCUPANCY_DILATION}, 0);
+    let last = min(i32(floor(slice_far)) + ${AVBOIT_OCCUPANCY_DILATION}, ${AVBOIT_VIRTUAL_SLICES_MAX - 1});
+    return vec2<i32>(first, last);
+}
+    `
+);

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

@@ -0,0 +1,9 @@
+/**
+ * The bits of occupancy word `word` (32 slices per word) that fall inside the inclusive slice
+ * range `[first, last]` — what the prepass ORs into that word.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_occupancy_word_mask: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_occupancy_word_mask.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_occupancy_word_mask.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_occupancy_word_mask.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,+CAFU,SAAS,CAmBjB;0BAzBwB,uCAAuC"}