@woosh/meep-engine 3.14.6 → 3.16.0

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

@@ -0,0 +1,26 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+
+/**
+ * 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.from(
+    //language=WGSL
+    `
+fn avboit_occupancy_word_mask(word: u32, first: i32, last: i32) -> u32 {
+    let base = i32(word * 32u);
+    let lo = max(first, base) - base;
+    let hi = min(last, base + 31) - base;
+    if (hi < lo) {
+        return 0u;
+    }
+    let count = u32(hi - lo + 1);
+    if (count >= 32u) {
+        return 0xFFFFFFFFu;
+    }
+    return ((1u << count) - 1u) << u32(lo);
+}
+    `
+);

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

@@ -0,0 +1,11 @@
+/**
+ * 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;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_overflows.d.ts.map

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

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

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_splat_slice.d.ts

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

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

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

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

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

package/src/shade/renderer/rasterize/native/avboit/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,
+    ]
+);