@woosh/meep-engine 3.14.5 → 3.15.0

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

@@ -0,0 +1,22 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { AVBOIT_EXTINCTION_SCALE } from "./AVBOIT_CONSTANTS.js";
+import { chunk_avboit_unpack_counts } from "./chunk_avboit_unpack_counts.js";
+
+/**
+ * Which channels an atomic add of `counts` pushed past 255, given the word's value before the add.
+ * The splat records the slice for each such channel; the integration pins the channel at full
+ * extinction from there on, since a ray that has overflowed a field is extinct anyway and the field
+ * may carry into its neighbour past that point.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_overflows = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_overflows(previous: u32, counts: vec3<u32>) -> vec3<bool> {
+    return (avboit_unpack_counts(previous) + counts) > vec3<u32>(${AVBOIT_EXTINCTION_SCALE}u);
+}
+    `, [
+        chunk_avboit_unpack_counts,
+    ]
+);

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

@@ -0,0 +1,10 @@
+/**
+ * Three channel counts into one `u32`, 10 bits each, R lowest. The fields hold 8-bit values with two
+ * guard bits each (deck slide 60), so four saturating events can pile up in one slice before a carry
+ * reaches the next channel; `avboit_overflows` is what catches the first one past 255.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_pack_counts: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_pack_counts.d.ts.map

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

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

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

@@ -0,0 +1,21 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { AVBOIT_FIELD_BITS } from "./AVBOIT_CONSTANTS.js";
+
+/**
+ * Three channel counts into one `u32`, 10 bits each, R lowest. The fields hold 8-bit values with two
+ * guard bits each (deck slide 60), so four saturating events can pile up in one slice before a carry
+ * reaches the next channel; `avboit_overflows` is what catches the first one past 255.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_pack_counts = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_pack_counts(counts: vec3<u32>) -> u32 {
+    var packed = insertBits(0u, counts.x, 0u, ${AVBOIT_FIELD_BITS}u);
+    packed = insertBits(packed, counts.y, ${AVBOIT_FIELD_BITS}u, ${AVBOIT_FIELD_BITS}u);
+    packed = insertBits(packed, counts.z, ${AVBOIT_FIELD_BITS * 2}u, ${AVBOIT_FIELD_BITS}u);
+    return packed;
+}
+    `
+);

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

@@ -0,0 +1,10 @@
+/**
+ * The RGB transmittance of everything in front of a fragment: a trilinear sample of the integral
+ * texture at the biased, warped depth, turned back into transmittance. The draw weights a fragment's
+ * whole contribution by it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_sample_transmittance: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_sample_transmittance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_sample_transmittance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_sample_transmittance.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,gDAFU,SAAS,CAqBjB;0BA/BwB,uCAAuC"}

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

@@ -0,0 +1,32 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { AVBOIT_WARP_STRUCT } from "./AVBOIT_WARP_STRUCT.js";
+import { chunk_avboit_extinction_to_transmittance } from "./chunk_avboit_extinction_to_transmittance.js";
+import { chunk_avboit_integral_depth_coordinate } from "./chunk_avboit_integral_depth_coordinate.js";
+
+/**
+ * The RGB transmittance of everything in front of a fragment: a trilinear sample of the integral
+ * texture at the biased, warped depth, turned back into transmittance. The draw weights a fragment's
+ * whole contribution by it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_sample_transmittance = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_sample_transmittance(
+    warp: ptr<storage, ${AVBOIT_WARP_STRUCT.wgsl_ref}, read>,
+    integral: texture_3d<f32>,
+    integral_sampler: sampler,
+    screen_uv: vec2<f32>,
+    z_view: f32,
+) -> vec3<f32> {
+    let w = avboit_integral_depth_coordinate(warp, z_view);
+    let extinction = textureSampleLevel(integral, integral_sampler, vec3<f32>(screen_uv, w), 0.0).rgb;
+    return avboit_extinction_to_transmittance(extinction);
+}
+    `, [
+        AVBOIT_WARP_STRUCT.declaration_chunk,
+        chunk_avboit_integral_depth_coordinate,
+        chunk_avboit_extinction_to_transmittance,
+    ]
+);

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

@@ -0,0 +1,20 @@
+/**
+ * The per-channel transmission tint of a surface — what colours the light it lets through.
+ *
+ * `mix(1, base colour, weight)`, clamped away from zero so its logarithm stays finite. With a weight
+ * of zero a surface tints nothing and lands exactly where MBOIT's scalar coverage puts it; with the
+ * material's `transmission_factor` as the weight, glass filters the background by its base colour.
+ * Used by both the splat (what the volume records) and the draw (what the accumulators record),
+ * which is the one place the two must agree; both take the weight as
+ * `transmission_factor × warp.tint_from_base_color`, so the renderer's `AVBOITSettings` decides.
+ *
+ * Base colour as the transmission colour is glTF's `KHR_materials_transmission` reading, not
+ * OpenPBR's (whose transmission colour defaults to white). The engine's material has no transmission
+ * colour of its own today, and its forward shader and path tracer transmit untinted — which is why
+ * the weight is off unless asked for.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_transmission_tint: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_transmission_tint.d.ts.map

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

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

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

@@ -0,0 +1,27 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+
+/**
+ * The per-channel transmission tint of a surface — what colours the light it lets through.
+ *
+ * `mix(1, base colour, weight)`, clamped away from zero so its logarithm stays finite. With a weight
+ * of zero a surface tints nothing and lands exactly where MBOIT's scalar coverage puts it; with the
+ * material's `transmission_factor` as the weight, glass filters the background by its base colour.
+ * Used by both the splat (what the volume records) and the draw (what the accumulators record),
+ * which is the one place the two must agree; both take the weight as
+ * `transmission_factor × warp.tint_from_base_color`, so the renderer's `AVBOITSettings` decides.
+ *
+ * Base colour as the transmission colour is glTF's `KHR_materials_transmission` reading, not
+ * OpenPBR's (whose transmission colour defaults to white). The engine's material has no transmission
+ * colour of its own today, and its forward shader and path tracer transmit untinted — which is why
+ * the weight is off unless asked for.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_transmission_tint = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_transmission_tint(base_color: vec3<f32>, weight: f32) -> vec3<f32> {
+    return clamp(mix(vec3<f32>(1.0), base_color, weight), vec3<f32>(1e-3), vec3<f32>(1.0));
+}
+    `
+);

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

@@ -0,0 +1,10 @@
+/**
+ * Per-channel transmittance to the volume's normalized extinction: `saturate(-ln T / ln 256)`, so
+ * `1.0` is a transmittance of `1/256`, which the integration treats as zero. Floored at `1e-6`
+ * before the logarithm so a fully opaque channel saturates instead of producing infinity.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_transmittance_to_extinction: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_transmittance_to_extinction.d.ts.map

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

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

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

@@ -0,0 +1,18 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { AVBOIT_EXTINCTION_MAX } from "./AVBOIT_CONSTANTS.js";
+
+/**
+ * Per-channel transmittance to the volume's normalized extinction: `saturate(-ln T / ln 256)`, so
+ * `1.0` is a transmittance of `1/256`, which the integration treats as zero. Floored at `1e-6`
+ * before the logarithm so a fully opaque channel saturates instead of producing infinity.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_transmittance_to_extinction = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_transmittance_to_extinction(transmittance: vec3<f32>) -> vec3<f32> {
+    return saturate(-log(max(transmittance, vec3<f32>(1e-6))) / ${AVBOIT_EXTINCTION_MAX});
+}
+    `
+);

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

@@ -0,0 +1,9 @@
+/**
+ * The three 10-bit channel fields of a packed extinction word, see `avboit_pack_counts`. A field
+ * that has summed past 255 reads as it is — the integration saturates, this does not.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_unpack_counts: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_unpack_counts.d.ts.map

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

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

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

@@ -0,0 +1,21 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { AVBOIT_FIELD_BITS } from "./AVBOIT_CONSTANTS.js";
+
+/**
+ * The three 10-bit channel fields of a packed extinction word, see `avboit_pack_counts`. A field
+ * that has summed past 255 reads as it is — the integration saturates, this does not.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_unpack_counts = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_unpack_counts(packed: u32) -> vec3<u32> {
+    return vec3<u32>(
+        extractBits(packed, 0u, ${AVBOIT_FIELD_BITS}u),
+        extractBits(packed, ${AVBOIT_FIELD_BITS}u, ${AVBOIT_FIELD_BITS}u),
+        extractBits(packed, ${AVBOIT_FIELD_BITS * 2}u, ${AVBOIT_FIELD_BITS}u),
+    );
+}
+    `
+);

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

@@ -0,0 +1,9 @@
+/**
+ * View-space depth straight to the continuous physical slice coordinate in `[0, P]` — the curve,
+ * then the warp. What the splat positions a fragment by.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_view_depth_to_physical: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_view_depth_to_physical.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_view_depth_to_physical.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_view_depth_to_physical.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,kDAFU,SAAS,CAajB;0BAtBwB,uCAAuC"}

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

@@ -0,0 +1,23 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.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";
+
+/**
+ * View-space depth straight to the continuous physical slice coordinate in `[0, P]` — the curve,
+ * then the warp. What the splat positions a fragment by.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_view_depth_to_physical = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_view_depth_to_physical(warp: ptr<storage, ${AVBOIT_WARP_STRUCT.wgsl_ref}, read>, z_view: f32) -> f32 {
+    return avboit_warp(warp, avboit_view_depth_to_virtual(warp, z_view));
+}
+    `, [
+        AVBOIT_WARP_STRUCT.declaration_chunk,
+        chunk_avboit_view_depth_to_virtual,
+        chunk_avboit_warp,
+    ]
+);

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

@@ -0,0 +1,13 @@
+/**
+ * View-space depth (world units) to the continuous virtual slice coordinate in `[0, V]`.
+ *
+ * The curve is the engine's log depth slicing (`cluster_depth_to_z_slice`, the light clusters' and
+ * the froxels'), with parameters built for the finest resolution by `avboit_build_depth_curve` and
+ * carried in the warp header. The active resolution `V` is that or a power-of-two fraction of it
+ * (plan §3.2), so the finest-level coordinate scales down by `V / V_max`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_view_depth_to_virtual: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_view_depth_to_virtual.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_view_depth_to_virtual.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_view_depth_to_virtual.js"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH,iDAFU,SAAS,CAajB;0BAzBwB,uCAAuC"}

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

@@ -0,0 +1,27 @@
+import { chunk_cluster_depth_to_z_slice } from "../../../light/cluster/chunk_cluster_depth_to_z_slice.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { AVBOIT_VIRTUAL_SLICES_MAX } from "./AVBOIT_CONSTANTS.js";
+import { AVBOIT_WARP_STRUCT } from "./AVBOIT_WARP_STRUCT.js";
+
+/**
+ * View-space depth (world units) to the continuous virtual slice coordinate in `[0, V]`.
+ *
+ * The curve is the engine's log depth slicing (`cluster_depth_to_z_slice`, the light clusters' and
+ * the froxels'), with parameters built for the finest resolution by `avboit_build_depth_curve` and
+ * carried in the warp header. The active resolution `V` is that or a power-of-two fraction of it
+ * (plan §3.2), so the finest-level coordinate scales down by `V / V_max`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_view_depth_to_virtual = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_view_depth_to_virtual(warp: ptr<storage, ${AVBOIT_WARP_STRUCT.wgsl_ref}, read>, z_view: f32) -> f32 {
+    let finest = cluster_depth_to_z_slice(z_view, (*warp).cluster_parameters, ${AVBOIT_VIRTUAL_SLICES_MAX}.0);
+    return finest * f32((*warp).virtual_count) / ${AVBOIT_VIRTUAL_SLICES_MAX}.0;
+}
+    `, [
+        AVBOIT_WARP_STRUCT.declaration_chunk,
+        chunk_cluster_depth_to_z_slice,
+    ]
+);

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

@@ -0,0 +1,22 @@
+/**
+ * The depth warp: virtual slice coordinate to physical slice coordinate, continuous and monotone.
+ *
+ * ```
+ * φ(v_f) = prefix(v) + occupied(v) · frac(v_f),   v = min(floor(v_f), V - 1)
+ * ```
+ *
+ * Slope 1 across an occupied virtual slice, flat across an empty one. Flat is what makes empty space
+ * disappear correctly: a coordinate that falls in a gap lands exactly on the physical boundary between
+ * the run before the gap and the run after it, and with the integral stored at slice boundaries
+ * (`shader_avboit_integrate`) that reads the previous run's whole total and none of the next run's.
+ * The deck's "filterable" begin/end flags exist to get the same effect out of a discrete LUT.
+ *
+ * Takes the whole warp binding by pointer: passing a pointer to a binding variable is core WGSL,
+ * where a pointer to one of its members is not, and the emulator models pointers as plain values so
+ * the same code runs in tests.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_warp: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_warp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_warp.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_warp.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH,gCAFU,SAAS,CAiBjB;0BArCwB,uCAAuC"}

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

@@ -0,0 +1,38 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { AVBOIT_WARP_STRUCT } from "./AVBOIT_WARP_STRUCT.js";
+
+/**
+ * The depth warp: virtual slice coordinate to physical slice coordinate, continuous and monotone.
+ *
+ * ```
+ * φ(v_f) = prefix(v) + occupied(v) · frac(v_f),   v = min(floor(v_f), V - 1)
+ * ```
+ *
+ * Slope 1 across an occupied virtual slice, flat across an empty one. Flat is what makes empty space
+ * disappear correctly: a coordinate that falls in a gap lands exactly on the physical boundary between
+ * the run before the gap and the run after it, and with the integral stored at slice boundaries
+ * (`shader_avboit_integrate`) that reads the previous run's whole total and none of the next run's.
+ * The deck's "filterable" begin/end flags exist to get the same effect out of a discrete LUT.
+ *
+ * Takes the whole warp binding by pointer: passing a pointer to a binding variable is core WGSL,
+ * where a pointer to one of its members is not, and the emulator models pointers as plain values so
+ * the same code runs in tests.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_warp = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_warp(warp: ptr<storage, ${AVBOIT_WARP_STRUCT.wgsl_ref}, read>, v_f: f32) -> f32 {
+    let count = max((*warp).virtual_count, 1u);
+    let v_clamped = clamp(v_f, 0.0, f32(count));
+    let v = min(u32(floor(v_clamped)), count - 1u);
+    let entry = (*warp).lut[v];
+    let prefix = f32(entry >> 1u);
+    let occupied = f32(entry & 1u);
+    return prefix + occupied * (v_clamped - f32(v));
+}
+    `, [
+        AVBOIT_WARP_STRUCT.declaration_chunk,
+    ]
+);

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

@@ -0,0 +1,117 @@
+/**
+ * Extinction volume XY resolution for an internal resolution.
+ *
+ * @param {ArrayLike<number>} resolution
+ * @returns {number[]}
+ */
+export function avboit_voxel_resolution(resolution: ArrayLike<number>): number[];
+/**
+ * Occupancy prepass over one bucket's HZB-filtered meshlets (plan §3.3).
+ *
+ * @param {FrameGraph} graph
+ * @param {GPUSceneContext} scene
+ * @param {number} camera resource ID
+ * @param {ArrayLike<number>} cluster_parameters the depth curve, see avboit_build_depth_curve
+ * @param {number} meshlet_collection resource ID, `MESHLET_COLLECTION_STRUCT` with its count header
+ * @param {number} meshlet_iterator_command resource ID, indirect dispatch over the collection
+ * @param {number} [occupancy] resource ID of an existing occupancy buffer to add to; created when -1
+ * @returns {number} resource ID of the occupancy bits
+ */
+export function graph_avboit_occupancy({ graph, scene, camera, cluster_parameters, meshlet_collection, meshlet_iterator_command, occupancy, }: FrameGraph): number;
+/**
+ * The depth-warp LUT from the occupancy bits (plan §3.4).
+ *
+ * @param {FrameGraph} graph
+ * @param {number} occupancy resource ID
+ * @param {number[]} voxel_resolution
+ * @param {ArrayLike<number>} cluster_parameters the depth curve, see avboit_build_depth_curve
+ * @param {AVBOITSettings} [avboit] the renderer's switches, carried into the header
+ * @returns {number} resource ID of the `AVBOIT_WARP_STRUCT` buffer
+ */
+export function graph_avboit_build_warp({ graph, occupancy, voxel_resolution, cluster_parameters, avboit, }: FrameGraph): number;
+/**
+ * Splat one bucket's transparent draws into the extinction volume (plan §3.5).
+ *
+ * @param {FrameGraph} graph
+ * @param {GPUViewContext} view_ctx
+ * @param {number} material_count
+ * @param {ShadeMaterial[]} materials
+ * @param {number} draw_commands resource ID
+ * @param {number} meshlets resource ID
+ * @param {number} camera resource ID
+ * @param {number} warp resource ID
+ * @param {number[]} voxel_resolution
+ * @param {PrimitiveState} primitive
+ * @param {{extinction: number, overflow: number, dummy: number}} [volume] existing resources to add to
+ * @returns {{extinction: number, overflow: number, dummy: number}}
+ */
+export function graph_avboit_splat({ graph, view_ctx, material_count, materials, draw_commands, meshlets, camera, warp, voxel_resolution, primitive, volume, }: FrameGraph): {
+    extinction: number;
+    overflow: number;
+    dummy: number;
+};
+/**
+ * Integrate the extinction volume into the 3D transmittance-integral texture (plan §3.6).
+ *
+ * @param {FrameGraph} graph
+ * @param {number} warp resource ID
+ * @param {number} extinction resource ID
+ * @param {number} overflow resource ID
+ * @param {number[]} voxel_resolution
+ * @returns {number} resource ID of the integral texture, `P + 1` slices deep
+ */
+export function graph_avboit_integrate({ graph, warp, extinction, overflow, voxel_resolution, }: FrameGraph): number;
+/**
+ * Draw one bucket's transparent materials with full shading into the three accumulators (plan §3.8).
+ *
+ * @param {FrameGraph} graph
+ * @param {GPUViewContext} view_ctx
+ * @param {number} material_count
+ * @param {ShadeMaterial[]} materials
+ * @param {number} draw_commands resource ID
+ * @param {number} meshlets resource ID
+ * @param {number} depth_texture resource ID
+ * @param {number} warp resource ID
+ * @param {number} integral resource ID
+ * @param {PrimitiveState} primitive
+ * @param {number} light_cluster_parameters
+ * @param {number} light_cluster_lookup
+ * @param {number} light_cluster_data
+ * @param {number} shadowmap_atlas
+ * @param {number} volumetrics_lut
+ * @param {number} volumetrics_metadata
+ * @param {{color: number, norm: number, extinction: number}} [accumulators] existing targets to add to
+ * @param {ShadeIndirectLightingMode} indirect_lighting_mode
+ * @returns {{color: number, norm: number, extinction: number}}
+ */
+export function graph_avboit_draw({ graph, view_ctx, material_count, materials, draw_commands, meshlets, depth_texture, warp, integral, primitive, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, accumulators, indirect_lighting_mode, }: FrameGraph): {
+    color: number;
+    norm: number;
+    extinction: number;
+};
+/**
+ * Adaptive voxel-based order-independent transparency (Drobot, SIGGRAPH 2025). Does not write depth.
+ *
+ * Same argument object and same return as `graph_rasterize_meshes_transparent_oit`, so `Renderer`
+ * selects between the two with `transparency_mode` alone. The passes it records are listed in
+ * `AVBOIT_PLAN_2026_09_03.md` §3.1.
+ *
+ * @param {FrameGraph} graph
+ * @param {number} buckets
+ * @param {GPUViewContext} view_ctx
+ * @param {number[]} viewport
+ * @param {number} color_texture resource ID
+ * @param {number} depth_texture resource ID
+ * @param {GPUCollectionLimits} limits
+ * @param {number} light_cluster_parameters
+ * @param {number} light_cluster_lookup
+ * @param {number} light_cluster_data
+ * @param {number} shadowmap_atlas
+ * @param {number} volumetrics_lut
+ * @param {number} volumetrics_metadata
+ * @param {ShadeIndirectLightingMode} indirect_lighting_mode
+ * @param {AVBOITSettings} [avboit] `Renderer.avboit`; the MBOIT orchestrator ignores it
+ * @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;
+//# sourceMappingURL=graph_rasterize_meshes_transparent_avboit.d.ts.map

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

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